Skip to content

Instantly share code, notes, and snippets.

@shapkarin

shapkarin/README.md

Last active April 2, 2024 14:55
Show Gist options
  • Save shapkarin/2b06b744fd92fd2a6aeaadb277c5d0b7 to your computer and use it in GitHub Desktop.
Save shapkarin/2b06b744fd92fd2a6aeaadb277c5d0b7 to your computer and use it in GitHub Desktop.
Download ZIP
Golang socket random
Raw
README.md

Solutions

  • crypto.go uses crypto/rand, which returns a big.Int.
  • uuid.go uses github.com/google/uuid that converts to a big.Int.

For both solutions:

Sockets are provided by github.com/gorilla/websocket.

The HTML interface is at localhost:8080.

Both solutions use usedNumbers to check if a number has already been generated.

The maximum value is 340282366920938463463374607431768211456 or 2^128 - 1, which is a 128-bit namespace.

Of course, there is some probability of smaller numbers being returned, like 1, 2, 3, etc.

Raw
crypto.go
package main
import (
"crypto/rand"
"html/template"
"log"
"math/big"
"net/http"
"sync"
"github.com/gorilla/websocket"
"flag"
)
const addrDefault = "localhost:8080"
const bitSize = 128
var addr = flag.String("addr", addrDefault, "http service address")
func main() {
flag.Parse()
log.SetFlags(0)
server := NewServer()
http.HandleFunc("/echo", server.echo)
http.HandleFunc("/", server.home)
log.Fatal(http.ListenAndServe(*addr, nil))
}
type Server struct {
upgrader websocket.Upgrader
usedNumbers map[string]*big.Int
mu sync.Mutex
}
func NewServer() *Server {
return &Server{
upgrader: websocket.Upgrader{
CheckOrigin: func(r *http.Request) bool {
return true // Adjust according to your CORS policy
},
},
usedNumbers: make(map[string]*big.Int),
}
}
func (s *Server) echo(w http.ResponseWriter, r *http.Request) {
c, err := s.upgrader.Upgrade(w, r, nil)
if err != nil {
log.Printf("upgrade error: %v", err)
return
}
defer c.Close()
for {
mt, message, err := c.ReadMessage()
if err != nil {
log.Printf("read error: %v", err)
break
}
log.Printf("recv: %s", message)
response, err := s.generateUniqueRandomBigInt()
if err != nil {
log.Printf("unique bigint generation error: %v", err)
break
}
err = c.WriteMessage(mt, []byte(response.String()))
if err != nil {
log.Printf("write error: %v", err)
break
}
}
}
func (s *Server) generateUniqueRandomBigInt() (*big.Int, error) {
s.mu.Lock()
defer s.mu.Unlock()
for {
num, err := rand.Int(rand.Reader, new(big.Int).Lsh(big.NewInt(1), bitSize))
if err != nil {
return nil, err
}
if _, exists := s.usedNumbers[num.String()]; !exists {
s.usedNumbers[num.String()] = num
return num, nil
}
}
}
func (s *Server) home(w http.ResponseWriter, r *http.Request) {
err := homeTemplate.Execute(w, "ws://"+r.Host+"/echo")
if err != nil {
log.Printf("template execution error: %v", err)
}
}
var homeTemplate = template.Must(template.New("").Parse(`
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<script>
window.addEventListener("load", function(evt) {
var output = document.getElementById("output");
var input = document.getElementById("input");
var ws;
var print = function(message) {
var d = document.createElement("div");
d.textContent = message;
output.appendChild(d);
output.scroll(0, output.scrollHeight);
};
document.getElementById("open").onclick = function(evt) {
if (ws) {
return false;
}
ws = new WebSocket("{{.}}");
ws.onopen = function(evt) {
print("OPEN");
}
ws.onclose = function(evt) {
print("CLOSE");
ws = null;
}
ws.onmessage = function(evt) {
print("RESPONSE: " + evt.data);
}
ws.onerror = function(evt) {
print("ERROR: " + evt.data);
}
return false;
};
document.getElementById("send").onclick = function(evt) {
if (!ws) {
return false;
}
print("SEND: " + input.value);
ws.send(input.value);
return false;
};
document.getElementById("close").onclick = function(evt) {
if (!ws) {
return false;
}
ws.close();
return false;
};
});
</script>
</head>
<body>
<table>
<tr><td valign="top" width="50%">
<p>Click "Open" to create a connection to the server,
"Send" to send a message to the server, and "Close" to close the connection.
You can change the message and send multiple times.
<p>
<form>
<button id="open">Open</button>
<button id="close">Close</button>
<p><input id="input" type="text" value="Hello world!">
<button id="send">Send</button>
</form>
</td><td valign="top" width="50%">
<div id="output" style="max-height: 70vh;overflow-y: scroll;"></div>
</td></tr></table>
</body>
</html>
`))
Raw
uuid.go
package main
import (
"flag"
"html/template"
"log"
"math/big"
"net/http"
"sync"
"github.com/gorilla/websocket"
"github.com/google/uuid"
)
var addr = flag.String("addr", "localhost:8080", "http service address")
var upgrader = websocket.Upgrader{}
var mutex sync.Mutex
var usedNumbers = make(map[string]bool)
func echo(w http.ResponseWriter, r *http.Request) {
c, err := upgrader.Upgrade(w, r, nil)
if err != nil {
log.Print("upgrade:", err)
return
}
defer c.Close()
for {
mt, message, err := c.ReadMessage()
if err != nil {
log.Println("read:", err)
break
}
log.Printf("recv: %s", message)
response, err := generateUniqueUUIDBigInt()
if err != nil {
log.Println("error generating unique big integer:", err)
break
}
err = c.WriteMessage(mt, []byte(response.String()))
if err != nil {
log.Println("write:", err)
break
}
}
}
func home(w http.ResponseWriter, r *http.Request) {
homeTemplate.Execute(w, "ws://"+r.Host+"/echo")
}
func generateUniqueUUIDBigInt() (*big.Int, error) {
uuidMutex := uuid.New()
mutex.Lock()
defer mutex.Unlock()
for usedNumbers[uuidMutex.String()] {
uuidMutex = uuid.New()
}
usedNumbers[uuidMutex.String()] = true
uuidBytes := uuidMutex[:]
intValue := new(big.Int).SetBytes(uuidBytes)
return intValue, nil
}
var homeTemplate = template.Must(template.New("").Parse(`
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<script>
window.addEventListener("load", function(evt) {
var output = document.getElementById("output");
var input = document.getElementById("input");
var ws;
var print = function(message) {
var d = document.createElement("div");
d.textContent = message;
output.appendChild(d);
output.scroll(0, output.scrollHeight);
};
document.getElementById("open").onclick = function(evt) {
if (ws) {
return false;
}
ws = new WebSocket("{{.}}");
ws.onopen = function(evt) {
print("OPEN");
}
ws.onclose = function(evt) {
print("CLOSE");
ws = null;
}
ws.onmessage = function(evt) {
print("RESPONSE: " + evt.data);
}
ws.onerror = function(evt) {
print("ERROR: " + evt.data);
}
return false;
};
document.getElementById("send").onclick = function(evt) {
if (!ws) {
return false;
}
print("SEND: " + input.value);
ws.send(input.value);
return false;
};
document.getElementById("close").onclick = function(evt) {
if (!ws) {
return false;
}
ws.close();
return false;
};
});
</script>
</head>
<body>
<table>
<tr><td valign="top" width="50%">
<p>Click "Open" to create a connection to the server,
"Send" to send a message to the server, and "Close" to close the connection.
You can change the message and send multiple times.
<p>
<form>
<button id="open">Open</button>
<button id="close">Close</button>
<p><input id="input" type="text" value="Hello world!">
<button id="send">Send</button>
</form>
</td><td valign="top" width="50%">
<div id="output" style="max-height: 70vh;overflow-y: scroll;"></div>
</td></tr></table>
</body>
</html>
`))
func main() {
flag.Parse()
log.SetFlags(0)
http.HandleFunc("/echo", echo)
http.HandleFunc("/", home)
log.Fatal(http.ListenAndServe(*addr, nil))
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment