dave/youtube-downloader
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove websockets

Browse Source
This commit is contained in:
David Majdandžić
2024-07-14 14:59:34 +02:00
parent 468de9e401
commit 8a51da97c2
11 changed files with 0 additions and 363 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
ws-client/go.mod
View File

@@ -1,5 +0,0 @@
module main
go 1.22.4
require github.com/gorilla/websocket v1.5.3

2
ws-client/go.sum
View File

@@ -1,2 +0,0 @@
github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=

73
ws-client/main.go
View File

@@ -1,73 +0,0 @@
package main
import (
"log"
"time"
"github.com/gorilla/websocket"
)
type WSConnection struct {
url string
conn *websocket.Conn
errChan chan error
}
func (ws *WSConnection) readMessage() {
log.Printf("Reading messages")
for {
_, message, err := ws.conn.ReadMessage()
if err != nil {
ws.errChan <- err
return
}
log.Printf("Received: %s", message)
}
}
func (ws *WSConnection) writeMessage(message string) {
err := ws.conn.WriteMessage(websocket.TextMessage, []byte(message))
if err != nil {
log.Printf("Error during message writing: %v", err)
ws.errChan <- err
return
}
}
func (ws *WSConnection) handleError() {
for {
err := <-ws.errChan
log.Println("Error during message reading:", err)
time.Sleep(5 * time.Second)
ws.open()
}
}
func (ws *WSConnection) open() {
log.Printf("Connecting to %s", ws.url)
conn, _, err := websocket.DefaultDialer.Dial(ws.url, nil)
if err != nil {
log.Println("Error during connection:", err)
ws.errChan <- err
return
}
log.Printf("Connected")
ws.conn = conn
ws.errChan = make(chan error)
go ws.readMessage()
go ws.handleError()
}
func main() {
log.SetFlags(log.Lmicroseconds)
wsConn := WSConnection{
url: "ws://localhost:8080/ws",
}
wsConn.open()
for {
log.Printf("zzz...")
time.Sleep(30 * time.Second)
}
}

3
ws-server/build.sh
View File

@@ -1,3 +0,0 @@
# docker build -t youtube-download-ws-server .
tar -cf deploy.tar captain-definition dockerfile *.go go.mod go.sum

4
ws-server/captain-definition
View File

@@ -1,4 +0,0 @@
{
"schemaVersion": 2,
"dockerfilePath": "./dockerfile"
}

113
ws-server/connection.go
View File

@@ -1,113 +0,0 @@
package main
import (
"log"
"sync"
"sync/atomic"
"time"
"github.com/gorilla/websocket"
)
type WSConnection struct {
id int32
conn *websocket.Conn
writeLock sync.Mutex
alive bool
ReadChan chan string
WriteChan chan string
ErrorChan chan error
IdleTimeout time.Duration
PingInterval time.Duration
}
func NewConn(conn *websocket.Conn, server *WSServer) *WSConnection {
wsconn := &WSConnection{
id: server.clientId,
conn: conn,
alive: true,
IdleTimeout: server.IdleTimeout,
PingInterval: server.PingInterval,
ReadChan: make(chan string, 1024),
WriteChan: make(chan string, 1024),
ErrorChan: make(chan error, 1),
}
atomic.AddInt32(&server.clientId, 1)
return wsconn
}
func (ws *WSConnection) Open() {
go ws.messageReader()
go ws.messageSender()
go ws.pinger()
ws.conn.SetPongHandler(func(string) error {
// log.Printf("Client %d: Pong OK", ws.id)
ws.conn.SetReadDeadline(time.Now().Add(ws.IdleTimeout))
return nil
})
}
func (ws *WSConnection) messageReader() {
log.Printf("Client %d: Reading messages", ws.id)
for {
_, message, err := ws.conn.ReadMessage()
if !ws.alive {
break
}
ws.conn.SetReadDeadline(time.Now().Add(ws.IdleTimeout))
if err != nil {
ws.ErrorChan <- err
break
}
log.Printf("Client %d: Received: %s, %d in output channel", ws.id, message, len(ws.ReadChan))
ws.ReadChan <- string(message)
}
log.Printf("Client %d: Stopped reading messages", ws.id)
}
func (ws *WSConnection) messageSender() {
log.Printf("Client %d: Sending messages", ws.id)
for {
msg, ok := <-ws.WriteChan
if !ok || !ws.alive {
break
}
ws.writeLock.Lock()
ws.conn.SetWriteDeadline(time.Now().Add(ws.IdleTimeout))
log.Printf("Client %d: Sending: %s, %d in input channel", ws.id, msg, len(ws.WriteChan))
err := ws.conn.WriteMessage(websocket.TextMessage, []byte(msg))
if err != nil {
log.Printf("Client %d: Error during message writing: %v", ws.id, err)
ws.ErrorChan <- err
ws.writeLock.Unlock()
break
}
ws.writeLock.Unlock()
}
log.Printf("Client %d: Stopped sending messages", ws.id)
}
func (ws *WSConnection) pinger() {
log.Printf("Client %d: Starting pinger, sleeping for %v", ws.id, ws.PingInterval)
for {
time.Sleep(ws.PingInterval)
if !ws.alive {
break
}
// log.Printf("Client %d: Ping", ws.id)
ws.writeLock.Lock()
err := ws.conn.WriteMessage(websocket.PingMessage, nil)
if err != nil {
log.Printf("Client %d: Error during ping: %+v", ws.id, err)
ws.ErrorChan <- err
break
}
ws.conn.SetWriteDeadline(time.Now().Add(ws.IdleTimeout))
ws.writeLock.Unlock()
// log.Printf("Client %d: Ping OK", ws.id)
}
log.Printf("Client %d: Stopped pinger", ws.id)
}

21
ws-server/dockerfile
View File

@@ -1,21 +0,0 @@
FROM golang:1.22.4 as base
WORKDIR $GOPATH/src/app/
COPY . .
RUN go mod download
RUN go mod verify
RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o /main .
FROM scratch
COPY --from=base /usr/share/zoneinfo /usr/share/zoneinfo
COPY --from=base /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
COPY --from=base /etc/passwd /etc/passwd
COPY --from=base /etc/group /etc/group
COPY --from=base /main .
CMD ["/main"]

5
ws-server/go.mod
View File

@@ -1,5 +0,0 @@
module main
go 1.22.4
require github.com/gorilla/websocket v1.5.3

2
ws-server/go.sum
View File

@@ -1,2 +0,0 @@
github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=

80
ws-server/main.go
View File

@@ -1,80 +0,0 @@
package main
import (
"encoding/json"
"fmt"
"io"
"log"
"net/http"
"time"
)
var server = New(10 * time.Second)
func wsHandler(responseWriter http.ResponseWriter, request *http.Request) {
conn, err := server.Upgrader.Upgrade(responseWriter, request, nil)
if err != nil {
fmt.Println("Error during connection upgrade:", err)
return
}
server.HandleNew(conn)
}
type DownloadReq struct {
Link string `json:"link"`
}
func handleDownload(responseWriter http.ResponseWriter, request *http.Request) {
body, err := io.ReadAll(request.Body)
if err != nil {
log.Printf("Error reading request body: %v", err)
http.Error(responseWriter, "Error reading request body", http.StatusBadRequest)
return
}
defer request.Body.Close()
req := DownloadReq{}
err = json.Unmarshal(body, &req)
if err != nil {
log.Printf("Error parsing JSON: %v", err)
http.Error(responseWriter, "Error parsing JSON", http.StatusBadRequest)
return
}
server.Broadcast <- req.Link
}
func init() {
// log.SetFlags(log.Lmicroseconds | log.Lshortfile)
log.SetFlags(log.Lmicroseconds)
}
// Mainly used to detect memory leaks
// func instrument() {
// numGoroutines := runtime.NumGoroutine()
// var m runtime.MemStats
// runtime.ReadMemStats(&m)
// malloc := float64(m.Alloc)
// ramUsedMB := malloc / 1024 / 1024
// kbPerGoroutine := malloc / 1024 / float64(numGoroutines)
// log.Printf("Number of active goroutines: %d; RAM used: %.2f MB; KB per goroutine: %.2f", numGoroutines, ramUsedMB, kbPerGoroutine)
// }
func main() {
// go func() {
// for {
// time.Sleep(1 * time.Second)
// instrument()
// }
// }()
http.HandleFunc("/ws", wsHandler)
http.HandleFunc("/download", handleDownload)
log.Println("Server starting on :8080")
err := http.ListenAndServe(":8080", nil)
if err != nil {
log.Println("Error starting server:", err)
}
}

55
ws-server/server.go
View File

@@ -1,55 +0,0 @@
package main
import (
"log"
"time"
"github.com/gorilla/websocket"
)
type WSServer struct {
connections map[*WSConnection]bool
clientId int32
Upgrader websocket.Upgrader
Broadcast chan string
IdleTimeout time.Duration
PingInterval time.Duration
}
func New(timeout time.Duration) *WSServer {
server := &WSServer{
connections: make(map[*WSConnection]bool),
Upgrader: websocket.Upgrader{},
Broadcast: make(chan string, 128),
IdleTimeout: timeout,
PingInterval: timeout / 2,
}
go func() {
for {
msg := <-server.Broadcast
for conn := range server.connections {
conn.WriteChan <- msg
}
}
}()
return server
}
func (server *WSServer) HandleNew(conn *websocket.Conn) {
log.Printf("Client connected, now %d clients", len(server.connections)+1)
wsconn := NewConn(conn, server)
go wsconn.Open()
server.connections[wsconn] = true
go func() {
err := <-wsconn.ErrorChan
wsconn.alive = false
close(wsconn.ReadChan)
close(wsconn.WriteChan)
close(wsconn.ErrorChan)
log.Printf("Client %d: disconnected due to %+v, now %d clients", wsconn.id, err, len(server.connections))
wsconn.conn.Close()
delete(server.connections, wsconn)
}()
}