config.go

@@ -7,6 +7,7 @@ import (
 	"os"
 	"strconv"
 	"strings"
+	"sync"
 
 	"github.com/fsnotify/fsnotify"
 	"gopkg.in/ini.v1"
@@ -55,6 +56,8 @@ func createConfig() error {
 		fmt.Printf("Generated connection code: %s\n", config.AuthCode)
 	}
 
+	config.NodesEnabled = len(config.Peers) > 0
+
 	saveConfig(config)
 	return nil
 }
@@ -69,6 +72,7 @@ func saveConfig(config Config) {
 	peers := strings.Join(config.Peers, ",")
 	sec.Key("Peers").SetValue(peers)
 	sec.Key("Domain").SetValue(config.Domain)
+	sec.Key("NodesEnabled").SetValue(strconv.FormatBool(config.NodesEnabled))
 
 	err := cfg.SaveTo(configFilePath)
 	if err != nil {
@@ -101,17 +105,25 @@ func loadConfig() Config {
 		domain = "localhost" // Default to localhost if not set
 	}
 
+	nodesEnabled, err := cfg.Section("").Key("NodesEnabled").Bool()
+	if err != nil { // If NodesEnabled is not found in config
+		nodesEnabled = len(peers) > 0 // Enable nodes if peers are configured
+	}
+
 	config = Config{
-		Port:     port,
-		AuthCode: cfg.Section("").Key("AuthCode").String(),
-		PeerID:   cfg.Section("").Key("PeerID").String(),
-		Peers:    peers,
-		Domain:   domain,
+		Port:         port,
+		AuthCode:     cfg.Section("").Key("AuthCode").String(),
+		PeerID:       cfg.Section("").Key("PeerID").String(),
+		Peers:        peers,
+		Domain:       domain,
+		NodesEnabled: nodesEnabled,
 	}
 
 	return config
 }
 
+var configLock sync.RWMutex
+
 func startFileWatcher() {
 	watcher, err := fsnotify.NewWatcher()
 	if err != nil {

files.go

@@ -1,7 +1,6 @@
 package main
 
 import (
-	"encoding/json"
 	"fmt"
 	"html/template"
 	"log"
@@ -50,8 +49,8 @@ func handleFileSearch(w http.ResponseWriter, query, safe, lang string, page int)
 
 	elapsedTime := time.Since(startTime)
 	funcMap := template.FuncMap{
-		"sub": subtract,
-		"add": add,
+		"sub": func(a, b int) int { return a - b },
+		"add": func(a, b int) int { return a + b },
 	}
 	tmpl, err := template.New("files.html").Funcs(funcMap).ParseFiles("templates/files.html")
 	if err != nil {
@@ -156,94 +155,11 @@ func fetchFileResults(query, safe, lang string, page int) []TorrentResult {
 	return results
 }
 
-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)
-		if err != nil {
-			log.Printf("Error contacting node %s: %v", nodeAddr, err)
-			continue
-		}
-		if len(results) > 0 {
-			return results
-		}
-	}
-	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)
-	if err != nil {
-		return nil, fmt.Errorf("failed to marshal search parameters: %v", err)
-	}
-
-	msg := Message{
-		ID:      hostID,
-		Type:    "search-file",
-		Content: string(msgBytes),
-	}
-
-	err = sendMessage(nodeAddr, msg)
-	if err != nil {
-		return nil, fmt.Errorf("failed to send search request to node %s: %v", nodeAddr, 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)
-	}
-}
-
-func handleFileResultsMessage(msg Message) {
-	var results []TorrentResult
-	err := json.Unmarshal([]byte(msg.Content), &results)
-	if err != nil {
-		log.Printf("Error unmarshalling file results: %v", err)
-		return
-	}
-
-	log.Printf("Received file results: %+v", results)
-	// Send results to fileResultsChan
-	go func() {
-		fileResultsChan <- results
-	}()
-}
-
 func removeMagnetLink(magnet string) string {
 	// Remove the magnet: prefix unconditionally
 	return strings.TrimPrefix(magnet, "magnet:")
 }
 
-func subtract(a, b int) int {
-	return a - b
-}
-
-func add(a, b int) int {
-	return a + b
-}
-
 func parseInt(s string) int {
 	i, err := strconv.Atoi(s)
 	if err != nil {

forums.go

@@ -138,69 +138,3 @@ func handleForumsSearch(w http.ResponseWriter, query, safe, lang string, page in
 		http.Error(w, fmt.Sprintf("Error rendering template: %v", err), http.StatusInternalServerError)
 	}
 }
-
-func tryOtherNodesForForumSearch(query, safe, lang string, page int) []ForumSearchResult {
-	for _, nodeAddr := range peers {
-		results, err := sendSearchRequestToNode(nodeAddr, query, safe, lang, page, []string{})
-		if err != nil {
-			log.Printf("Error contacting node %s: %v", nodeAddr, err)
-			continue
-		}
-		if len(results) > 0 {
-			return results
-		}
-	}
-	return nil
-}
-
-func sendSearchRequestToNode(nodeAddr, query, safe, lang string, page int, visitedNodes []string) ([]ForumSearchResult, error) {
-	// Check if the current node has already been visited
-	for _, node := range visitedNodes {
-		if node == hostID {
-			return nil, fmt.Errorf("loop detected: this node (%s) has already been visited", hostID)
-		}
-	}
-
-	// Add current node to the list of visited nodes
-	visitedNodes = append(visitedNodes, hostID)
-
-	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)
-	if err != nil {
-		return nil, fmt.Errorf("failed to marshal search parameters: %v", err)
-	}
-
-	msg := Message{
-		ID:      hostID,
-		Type:    "search-forum",
-		Content: string(msgBytes),
-	}
-
-	err = sendMessage(nodeAddr, msg)
-	if err != nil {
-		return nil, fmt.Errorf("failed to send search request to node %s: %v", nodeAddr, err)
-	}
-
-	// Wait for results
-	select {
-	case res := <-resultsChan:
-		return res, nil
-	case <-time.After(20 * time.Second):
-		return nil, fmt.Errorf("timeout waiting for results from node %s", nodeAddr)
-	}
-}

images.go

@@ -1,7 +1,6 @@
 package main
 
 import (
-	"encoding/json"
 	"fmt"
 	"html/template"
 	"log"
@@ -10,7 +9,6 @@ import (
 )
 
 var imageSearchEngines []SearchEngine
-var imageResultsChan = make(chan []ImageSearchResult)
 
 func init() {
 	imageSearchEngines = []SearchEngine{
@@ -131,66 +129,6 @@ func fetchImageResults(query, safe, lang string, page int) []ImageSearchResult {
 	return results
 }
 
-func tryOtherNodesForImageSearch(query, safe, lang string, page int, visitedNodes []string) []ImageSearchResult {
-	for _, nodeAddr := range peers {
-		if contains(visitedNodes, nodeAddr) {
-			continue // Skip nodes already visited
-		}
-		results, err := sendImageSearchRequestToNode(nodeAddr, query, safe, lang, page, visitedNodes)
-		if err != nil {
-			log.Printf("Error contacting node %s: %v", nodeAddr, err)
-			continue
-		}
-		if len(results) > 0 {
-			return results
-		}
-	}
-	return nil
-}
-
-func sendImageSearchRequestToNode(nodeAddr, query, safe, lang string, page int, visitedNodes []string) ([]ImageSearchResult, 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)
-	if err != nil {
-		return nil, fmt.Errorf("failed to marshal search parameters: %v", err)
-	}
-
-	msg := Message{
-		ID:      hostID,
-		Type:    "search-image",
-		Content: string(msgBytes),
-	}
-
-	err = sendMessage(nodeAddr, msg)
-	if err != nil {
-		return nil, fmt.Errorf("failed to send search request to node %s: %v", nodeAddr, err)
-	}
-
-	// Wait for results
-	select {
-	case res := <-imageResultsChan:
-		return res, nil
-	case <-time.After(30 * time.Second):
-		return nil, fmt.Errorf("timeout waiting for results from node %s", nodeAddr)
-	}
-}
-
 func wrapImageSearchFunc(f func(string, string, string, int) ([]ImageSearchResult, time.Duration, error)) func(string, string, string, int) ([]SearchResult, time.Duration, error) {
 	return func(query, safe, lang string, page int) ([]SearchResult, time.Duration, error) {
 		imageResults, duration, err := f(query, safe, lang, page)
@@ -204,18 +142,3 @@ func wrapImageSearchFunc(f func(string, string, string, int) ([]ImageSearchResul
 		return searchResults, duration, nil
 	}
 }
-
-func handleImageResultsMessage(msg Message) {
-	var results []ImageSearchResult
-	err := json.Unmarshal([]byte(msg.Content), &results)
-	if err != nil {
-		log.Printf("Error unmarshalling image results: %v", err)
-		return
-	}
-
-	log.Printf("Received image results: %+v", results)
-	// Send results to imageResultsChan
-	go func() {
-		imageResultsChan <- results
-	}()
-}

init.go

@@ -3,27 +3,28 @@ package main
 import (
 	"fmt"
 	"log"
-	"sync"
 	"time"
 )
 
 type Config struct {
-	Port     int
-	AuthCode string
-	Peers    []string
-	PeerID   string
-	Domain   string
+	Port         int
+	AuthCode     string
+	PeerID       string
+	Peers        []string
+	Domain       string
+	NodesEnabled bool
 }
 
 var defaultConfig = Config{
-	Port:   5000,
-	Domain: "localhost",
+	Port:     5000,
+	Domain:   "localhost",
+	Peers:    []string{},
+	AuthCode: generateStrongRandomString(64),
 }
 
 const configFilePath = "config.ini"
 
 var config Config
-var configLock sync.RWMutex
 
 func main() {
 	err := initConfig()

node-handle-search.go

@@ -3,12 +3,6 @@ package main
 import (
 	"encoding/json"
 	"log"
-	"sync"
-)
-
-var (
-	forumResults      = make(map[string][]ForumSearchResult)
-	forumResultsMutex sync.Mutex
 )
 
 func handleSearchTextMessage(msg Message) {

node-request-files.go

@@ -0,0 +1,83 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"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)
+		if err != nil {
+			log.Printf("Error contacting node %s: %v", nodeAddr, err)
+			continue
+		}
+		if len(results) > 0 {
+			return results
+		}
+	}
+	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)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal search parameters: %v", err)
+	}
+
+	msg := Message{
+		ID:      hostID,
+		Type:    "search-file",
+		Content: string(msgBytes),
+	}
+
+	err = sendMessage(nodeAddr, msg)
+	if err != nil {
+		return nil, fmt.Errorf("failed to send search request to node %s: %v", nodeAddr, 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)
+	}
+}
+
+func handleFileResultsMessage(msg Message) {
+	var results []TorrentResult
+	err := json.Unmarshal([]byte(msg.Content), &results)
+	if err != nil {
+		log.Printf("Error unmarshalling file results: %v", err)
+		return
+	}
+
+	log.Printf("Received file results: %+v", results)
+	// Send results to fileResultsChan
+	go func() {
+		fileResultsChan <- results
+	}()
+}

node-request-forums.go

@@ -0,0 +1,101 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"time"
+)
+
+var forumResultsChan = make(chan []ForumSearchResult)
+
+func tryOtherNodesForForumSearch(query, safe, lang string, page int) []ForumSearchResult {
+	for _, nodeAddr := range peers {
+		results, err := sendForumSearchRequestToNode(nodeAddr, query, safe, lang, page, []string{})
+		if err != nil {
+			log.Printf("Error contacting node %s: %v", nodeAddr, err)
+			continue
+		}
+		if len(results) > 0 {
+			return results
+		}
+	}
+	return nil
+}
+
+func sendForumSearchRequestToNode(nodeAddr, query, safe, lang string, page int, visitedNodes []string) ([]ForumSearchResult, error) {
+	// Check if the current node has already been visited
+	for _, node := range visitedNodes {
+		if node == hostID {
+			return nil, fmt.Errorf("loop detected: this node (%s) has already been visited", hostID)
+		}
+	}
+
+	// Add current node to the list of visited nodes
+	visitedNodes = append(visitedNodes, hostID)
+
+	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)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal search parameters: %v", err)
+	}
+
+	msg := Message{
+		ID:      hostID,
+		Type:    "search-forum",
+		Content: string(msgBytes),
+	}
+
+	err = sendMessage(nodeAddr, msg)
+	if err != nil {
+		return nil, fmt.Errorf("failed to send search request to node %s: %v", nodeAddr, err)
+	}
+
+	// Wait for results
+	select {
+	case res := <-forumResultsChan:
+		return res, nil
+	case <-time.After(20 * time.Second):
+		return nil, fmt.Errorf("timeout waiting for results from node %s", nodeAddr)
+	}
+}
+
+func handleForumResultsMessage(msg Message) {
+	var results []ForumSearchResult
+	err := json.Unmarshal([]byte(msg.Content), &results)
+	if err != nil {
+		log.Printf("Error unmarshalling forum results: %v", err)
+		return
+	}
+
+	log.Printf("Received forum results: %+v", results)
+	// Send results to forumResultsChan
+	go func() {
+		forumResultsChan <- results
+	}()
+}
+
+// Used only to answer requests
+func fetchForumResults(query, safe, lang string, page int) []ForumSearchResult {
+	results, err := PerformRedditSearch(query, safe, page)
+	if err != nil {
+		log.Printf("Error fetching forum results: %v", err)
+		return nil
+	}
+	return results
+}

node-request-images.go

@@ -0,0 +1,85 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"time"
+)
+
+var imageResultsChan = make(chan []ImageSearchResult)
+
+func handleImageResultsMessage(msg Message) {
+	var results []ImageSearchResult
+	err := json.Unmarshal([]byte(msg.Content), &results)
+	if err != nil {
+		log.Printf("Error unmarshalling image results: %v", err)
+		return
+	}
+
+	log.Printf("Received image results: %+v", results)
+	// Send results to imageResultsChan
+	go func() {
+		imageResultsChan <- results
+	}()
+}
+
+func sendImageSearchRequestToNode(nodeAddr, query, safe, lang string, page int, visitedNodes []string) ([]ImageSearchResult, 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)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal search parameters: %v", err)
+	}
+
+	msg := Message{
+		ID:      hostID,
+		Type:    "search-image",
+		Content: string(msgBytes),
+	}
+
+	err = sendMessage(nodeAddr, msg)
+	if err != nil {
+		return nil, fmt.Errorf("failed to send search request to node %s: %v", nodeAddr, err)
+	}
+
+	// Wait for results
+	select {
+	case res := <-imageResultsChan:
+		return res, nil
+	case <-time.After(30 * time.Second):
+		return nil, fmt.Errorf("timeout waiting for results from node %s", nodeAddr)
+	}
+}
+
+func tryOtherNodesForImageSearch(query, safe, lang string, page int, visitedNodes []string) []ImageSearchResult {
+	for _, nodeAddr := range peers {
+		if contains(visitedNodes, nodeAddr) {
+			continue // Skip nodes already visited
+		}
+		results, err := sendImageSearchRequestToNode(nodeAddr, query, safe, lang, page, visitedNodes)
+		if err != nil {
+			log.Printf("Error contacting node %s: %v", nodeAddr, err)
+			continue
+		}
+		if len(results) > 0 {
+			return results
+		}
+	}
+	return nil
+}

node-request-search.go

@@ -1,64 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"log"
-)
-
-////// FORUMS /////
-
-var resultsChan = make(chan []ForumSearchResult)
-
-func sendForumResults(responseAddr string, results []ForumSearchResult) {
-	resultsMsg := Message{
-		ID:      hostID,
-		Type:    "forum-results",
-		Content: marshalResults(results),
-	}
-
-	err := sendMessage(responseAddr, resultsMsg)
-	if err != nil {
-		log.Printf("Error sending forum search results to %s: %v", responseAddr, err)
-	} else {
-		log.Printf("Forum search results sent successfully to %s", responseAddr)
-	}
-}
-
-func marshalResults(results []ForumSearchResult) string {
-	content, err := json.Marshal(results)
-	if err != nil {
-		log.Printf("Error marshalling forum results: %v", err)
-		return ""
-	}
-	return string(content)
-}
-
-func handleForumResultsMessage(msg Message) {
-	var results []ForumSearchResult
-	err := json.Unmarshal([]byte(msg.Content), &results)
-	if err != nil {
-		log.Printf("Error unmarshalling forum results: %v", err)
-		return
-	}
-
-	log.Printf("Received forum results: %+v", results)
-	// Send results to resultsChan
-	go func() {
-		resultsChan <- results
-	}()
-}
-
-func fetchForumResults(query, safe, lang string, page int) []ForumSearchResult {
-	results, err := PerformRedditSearch(query, safe, page)
-	if err != nil {
-		log.Printf("Error fetching forum results: %v", err)
-		return nil
-	}
-	return results
-}
-
-////// FORUMS //////
-
-////// IMAGES /////
-
-////// IMAGES /////

node-request-text.go

@@ -0,0 +1,85 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"time"
+)
+
+var textResultsChan = make(chan []TextSearchResult)
+
+func tryOtherNodesForTextSearch(query, safe, lang string, page int, visitedNodes []string) []TextSearchResult {
+	for _, nodeAddr := range peers {
+		if contains(visitedNodes, nodeAddr) {
+			continue // Skip nodes already visited
+		}
+		results, err := sendTextSearchRequestToNode(nodeAddr, query, safe, lang, page, visitedNodes)
+		if err != nil {
+			log.Printf("Error contacting node %s: %v", nodeAddr, err)
+			continue
+		}
+		if len(results) > 0 {
+			return results
+		}
+	}
+	return nil
+}
+
+func sendTextSearchRequestToNode(nodeAddr, query, safe, lang string, page int, visitedNodes []string) ([]TextSearchResult, 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)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal search parameters: %v", err)
+	}
+
+	msg := Message{
+		ID:      hostID,
+		Type:    "search-text",
+		Content: string(msgBytes),
+	}
+
+	err = sendMessage(nodeAddr, msg)
+	if err != nil {
+		return nil, fmt.Errorf("failed to send search request to node %s: %v", nodeAddr, err)
+	}
+
+	// Wait for results
+	select {
+	case res := <-textResultsChan:
+		return res, nil
+	case <-time.After(20 * time.Second):
+		return nil, fmt.Errorf("timeout waiting for results from node %s", nodeAddr)
+	}
+}
+
+func handleTextResultsMessage(msg Message) {
+	var results []TextSearchResult
+	err := json.Unmarshal([]byte(msg.Content), &results)
+	if err != nil {
+		log.Printf("Error unmarshalling text results: %v", err)
+		return
+	}
+
+	log.Printf("Received text results: %+v", results)
+	// Send results to textResultsChan
+	go func() {
+		textResultsChan <- results
+	}()
+}

node-request-video.go

@@ -0,0 +1,83 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"time"
+)
+
+func tryOtherNodesForVideoSearch(query, safe, lang string, page int, visitedNodes []string) []VideoResult {
+	for _, nodeAddr := range peers {
+		if contains(visitedNodes, nodeAddr) {
+			continue // Skip nodes already visited
+		}
+		results, err := sendVideoSearchRequestToNode(nodeAddr, query, safe, lang, page, visitedNodes)
+		if err != nil {
+			log.Printf("Error contacting node %s: %v", nodeAddr, err)
+			continue
+		}
+		if len(results) > 0 {
+			return results
+		}
+	}
+	return nil
+}
+
+func sendVideoSearchRequestToNode(nodeAddr, query, safe, lang string, page int, visitedNodes []string) ([]VideoResult, 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)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal search parameters: %v", err)
+	}
+
+	msg := Message{
+		ID:      hostID,
+		Type:    "search-video",
+		Content: string(msgBytes),
+	}
+
+	err = sendMessage(nodeAddr, msg)
+	if err != nil {
+		return nil, fmt.Errorf("failed to send search request to node %s: %v", nodeAddr, err)
+	}
+
+	// Wait for results
+	select {
+	case res := <-videoResultsChan:
+		return res, nil
+	case <-time.After(20 * time.Second):
+		return nil, fmt.Errorf("timeout waiting for results from node %s", nodeAddr)
+	}
+}
+
+func handleVideoResultsMessage(msg Message) {
+	var results []VideoResult
+	err := json.Unmarshal([]byte(msg.Content), &results)
+	if err != nil {
+		log.Printf("Error unmarshalling video results: %v", err)
+		return
+	}
+
+	log.Printf("Received video results: %+v", results)
+	// Send results to videoResultsChan
+	go func() {
+		videoResultsChan <- results
+	}()
+}

text.go

@@ -1,7 +1,6 @@
 package main
 
 import (
-	"encoding/json"
 	"fmt"
 	"html/template"
 	"log"
@@ -10,7 +9,6 @@ import (
 )
 
 var textSearchEngines []SearchEngine
-var textResultsChan = make(chan []TextSearchResult)
 
 func init() {
 	textSearchEngines = []SearchEngine{
@@ -182,78 +180,3 @@ func wrapTextSearchFunc(f func(string, string, string, int) ([]TextSearchResult,
 		return searchResults, duration, nil
 	}
 }
-
-func tryOtherNodesForTextSearch(query, safe, lang string, page int, visitedNodes []string) []TextSearchResult {
-	for _, nodeAddr := range peers {
-		if contains(visitedNodes, nodeAddr) {
-			continue // Skip nodes already visited
-		}
-		results, err := sendTextSearchRequestToNode(nodeAddr, query, safe, lang, page, visitedNodes)
-		if err != nil {
-			log.Printf("Error contacting node %s: %v", nodeAddr, err)
-			continue
-		}
-		if len(results) > 0 {
-			return results
-		}
-	}
-	return nil
-}
-
-func sendTextSearchRequestToNode(nodeAddr, query, safe, lang string, page int, visitedNodes []string) ([]TextSearchResult, 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)
-	if err != nil {
-		return nil, fmt.Errorf("failed to marshal search parameters: %v", err)
-	}
-
-	msg := Message{
-		ID:      hostID,
-		Type:    "search-text",
-		Content: string(msgBytes),
-	}
-
-	err = sendMessage(nodeAddr, msg)
-	if err != nil {
-		return nil, fmt.Errorf("failed to send search request to node %s: %v", nodeAddr, err)
-	}
-
-	// Wait for results
-	select {
-	case res := <-textResultsChan:
-		return res, nil
-	case <-time.After(20 * time.Second):
-		return nil, fmt.Errorf("timeout waiting for results from node %s", nodeAddr)
-	}
-}
-
-func handleTextResultsMessage(msg Message) {
-	var results []TextSearchResult
-	err := json.Unmarshal([]byte(msg.Content), &results)
-	if err != nil {
-		log.Printf("Error unmarshalling text results: %v", err)
-		return
-	}
-
-	log.Printf("Received text results: %+v", results)
-	// Send results to textResultsChan
-	go func() {
-		textResultsChan <- results
-	}()
-}

video.go

@@ -209,78 +209,3 @@ func fetchVideoResults(query, safe, lang string, page int) []VideoResult {
 	}
 	return results
 }
-
-func tryOtherNodesForVideoSearch(query, safe, lang string, page int, visitedNodes []string) []VideoResult {
-	for _, nodeAddr := range peers {
-		if contains(visitedNodes, nodeAddr) {
-			continue // Skip nodes already visited
-		}
-		results, err := sendVideoSearchRequestToNode(nodeAddr, query, safe, lang, page, visitedNodes)
-		if err != nil {
-			log.Printf("Error contacting node %s: %v", nodeAddr, err)
-			continue
-		}
-		if len(results) > 0 {
-			return results
-		}
-	}
-	return nil
-}
-
-func sendVideoSearchRequestToNode(nodeAddr, query, safe, lang string, page int, visitedNodes []string) ([]VideoResult, 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)
-	if err != nil {
-		return nil, fmt.Errorf("failed to marshal search parameters: %v", err)
-	}
-
-	msg := Message{
-		ID:      hostID,
-		Type:    "search-video",
-		Content: string(msgBytes),
-	}
-
-	err = sendMessage(nodeAddr, msg)
-	if err != nil {
-		return nil, fmt.Errorf("failed to send search request to node %s: %v", nodeAddr, err)
-	}
-
-	// Wait for results
-	select {
-	case res := <-videoResultsChan:
-		return res, nil
-	case <-time.After(20 * time.Second):
-		return nil, fmt.Errorf("timeout waiting for results from node %s", nodeAddr)
-	}
-}
-
-func handleVideoResultsMessage(msg Message) {
-	var results []VideoResult
-	err := json.Unmarshal([]byte(msg.Content), &results)
-	if err != nil {
-		log.Printf("Error unmarshalling video results: %v", err)
-		return
-	}
-
-	log.Printf("Received video results: %+v", results)
-	// Send results to videoResultsChan
-	go func() {
-		videoResultsChan <- results
-	}()
-}