1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19
20. 20
21. 21
22. 22
23. 23
24. 24
25. 25
26. 26
27. 27
28. 28
29. 29
30. 30
31. 31
32. 32
33. 33
34. 34
35. 35
36. 36
37. 37
38. 38
39. 39
40. 40
41. 41
42. 42
43. 43
44. 44
45. 45
46. 46
47. 47
48. 48
49. 49
50. 50
51. 51
52. 52
53. 53
54. 54
55. 55
56. 56
57. 57
58. 58
59. 59
60. 60
61. 61
62. 62
63. 63
64. 64
65. 65
66. 66
67. 67
68. 68
69. 69
70. 70
71. 71
72. 72
73. 73
74. 74
75. 75
76. 76
77. 77
78. 78
79. 79
80. 80
81. 81
82. 82
83. 83
84. 84
85. 85
86. 86
87. 87
88. 88
89. 89
90. 90
91. 91
92. 92
93. 93
94. 94
95. 95
96. 96
97. 97
98. 98
99. 99
100. 100
101. 101
102. 102
103. 103
104. 104
105. 105
106. 106
107. 107
108. 108
109. 109
110. 110
111. 111
112. 112
113. 113
114. 114
115. 115

package main

import (
	"crypto/sha256"
	"encoding/hex"
	"flag"
	"fmt"
	"io"
	"log"
	"net/http"
	"sort"
	"strings"
	"sync"
)

var mu sync.Mutex
var me string
var hashToDomain map[string]string
var peerHashes []string
var kvstore map[string]string

func sha256sum(s string) string {
	// Get the sha256sum of string as a hex string
	b := sha256.Sum256([]byte(s))
	return hex.EncodeToString(b[:])
}

func addPeer(peer string) error {
	// Try to peer with another server
	peerHash := sha256sum(peer)
	// Check if already peered
	mu.Lock()
	_, ok := hashToDomain[peerHash]
	mu.Unlock()
	if ok {
		return nil
	}
	mu.Lock()
	hashToDomain[peerHash] = peer
	mu.Unlock()

	// Try request to peer
	log.Printf("%s trying to peer with %s", me, peer)
	resp, err := http.Get(peer + "/peer?peer=" + me)
	if err != nil {
		// Request failed, delete peer
		mu.Lock()
		delete(hashToDomain, peerHash)
		mu.Unlock()
		return err
	}

	log.Printf("%s successfully peered with %s", me, peer)
	mu.Lock()
	peerHashes = append(peerHashes, peerHash)
	sort.Sort(sort.StringSlice(peerHashes))
	mu.Unlock()
	// Read response body
	defer resp.Body.Close()
	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return err
	}
	// Try adding all peers of this peer
	newPeers := strings.Split(string(body), "\n")
	for _, newPeer := range newPeers[:len(newPeers)-1] {
		go addPeer(newPeer)
	}
	return nil
}

func peerHandler(w http.ResponseWriter, r *http.Request) {
	// Handle incoming peer requests
	r.ParseForm()
	peer := r.Form.Get("peer")
	if peer == "" {
		w.WriteHeader(http.StatusBadRequest)
		return
	}
	go addPeer(peer)
	for _, p := range hashToDomain {
		fmt.Fprintf(w, "%s\n", p)
	}
}

func getHandler(w http.ResponseWriter, r *http.Request) {

}

func setHandler(w http.ResponseWriter, r *http.Request) {

}

func main() {
	bindAddr := flag.String("b", ":4200", "bind address")
	domain := flag.String("d", "http://localhost:4200", "full domain name")
	peer := flag.String("i", "", "initial peer")
	flag.Parse()

	log.Printf("Starting %s %s %s", *bindAddr, *domain, *peer)

	// Record myself
	me = *domain
	peerHashes = append(peerHashes, sha256sum(me))
	hashToDomain = map[string]string{peerHashes[0]: me}

	if *peer != "" {
		go addPeer(*peer)
	}

	http.HandleFunc("/peer", peerHandler)
	http.HandleFunc("/get", getHandler)
	http.HandleFunc("/set", setHandler)
	log.Fatal(http.ListenAndServe(*bindAddr, nil))
}