public/chat-signaling-server
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

#

Browse Source
This commit is contained in:
guochao
2024-01-26 22:59:42 +08:00
parent b51f725480
commit 56cc4cb993
8 changed files with 151 additions and 77 deletions
Download Patch File Download Diff File Expand all files Collapse all files

92
cmd/demo-signal-client/main.go
View File

@ -3,10 +3,11 @@ package main
import (
"bytes"
"context"
"crypto/tls"
"encoding/json"
"flag"
"fmt"
"io"
"net/url"
"strings"
"sync"
@ -15,8 +16,10 @@ import (
"github.com/charmbracelet/bubbles/viewport"
tea "github.com/charmbracelet/bubbletea"
"github.com/charmbracelet/lipgloss"
"github.com/spf13/cobra"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials"
"google.golang.org/grpc/credentials/insecure"
"github.com/pion/webrtc/v3"
@ -52,6 +55,9 @@ type SignalClient struct {
webrtcConfig webrtc.Configuration
Server string
Credential credentials.TransportCredentials
Room string
Name string
@ -69,7 +75,7 @@ type SignalClient struct {
Lock sync.Locker
}
func New(room, name string) *SignalClient {
func New(server, room string, iceServers []string) *SignalClient {
ta := textarea.New()
ta.Prompt = "Send a message"
ta.Focus()
@ -86,6 +92,15 @@ Type a message and press Enter to send.`)
ta.KeyMap.InsertNewline.SetEnabled(false)
transportCredential := insecure.NewCredentials()
parsedUrl, err := url.Parse(server)
if err != nil {
panic(err)
}
if parsedUrl.Scheme == "https" {
transportCredential = credentials.NewTLS(&tls.Config{})
}
client := &SignalClient{
UI: SignalClientUI{
viewport: vp,
@ -95,13 +110,15 @@ Type a message and press Enter to send.`)
webrtcConfig: webrtc.Configuration{
ICEServers: []webrtc.ICEServer{
{
URLs: []string{"stun:nhz.jeffthecoder.xyz:3478", "stun:nhz.jeffthecoder.xyz:3479"},
URLs: iceServers,
},
},
},
Server: fmt.Sprintf("%v:%v", parsedUrl.Hostname(), parsedUrl.Port()),
Credential: transportCredential,
Room: room,
Name: name,
PeerConns: make(map[string]*webrtc.PeerConnection),
Channels: make(map[string]*webrtc.DataChannel),
@ -192,7 +209,7 @@ func (client *SignalClient) View() string {
func (client *SignalClient) ConnectServer(ctx context.Context) {
client.Program.Send(systemMsg("Dialing to server..."))
grpcClient, err := grpc.Dial("127.0.0.1:4444", grpc.WithTransportCredentials(insecure.NewCredentials()))
grpcClient, err := grpc.Dial(client.Server, grpc.WithTransportCredentials(client.Credential))
if err != nil {
panic(err)
}
@ -211,13 +228,11 @@ func (client *SignalClient) ConnectServer(ctx context.Context) {
func (client *SignalClient) HandleConnection(ctx context.Context, grpcClient *grpc.ClientConn, stream proto.Signaling_BiuClient) {
defer grpcClient.Close()
room := client.Room
clientId := client.Name
client.Program.Send(systemMsg("Waiting for server to be bootstrapped."))
stream.Send(&proto.SignalingMessage{
Room: room,
Sender: clientId,
Message: &proto.SignalingMessage_Bootstrap{},
})
@ -233,13 +248,13 @@ func (client *SignalClient) HandleConnection(ctx context.Context, grpcClient *gr
}
switch inner := msg.Message.(type) {
case *proto.SignalingMessage_Bootstrap:
client.OnBootstrapReady(ctx, stream, room, clientId)
client.OnBootstrapReady(ctx, stream, room, msg.Sender)
case *proto.SignalingMessage_DiscoverRequest:
client.OnDiscoverRequest(ctx, stream, room, clientId, msg.Sender)
client.OnDiscoverRequest(ctx, stream, room, msg.Sender)
case *proto.SignalingMessage_DiscoverResponse:
client.OnDiscoverResponse(ctx, stream, room, clientId, msg.Sender)
client.OnDiscoverResponse(ctx, stream, room, msg.Sender)
case *proto.SignalingMessage_SessionOffer:
client.OnOffer(ctx, stream, room, clientId, msg.Sender, inner.SessionOffer.SDP)
client.OnOffer(ctx, stream, room, msg.Sender, inner.SessionOffer.SDP)
case *proto.SignalingMessage_SessionAnswer:
client.OnAnswer(ctx, msg.Sender, inner.SessionAnswer.SDP)
}
@ -247,25 +262,27 @@ func (client *SignalClient) HandleConnection(ctx context.Context, grpcClient *gr
}
func (client *SignalClient) OnBootstrapReady(ctx context.Context, stream proto.Signaling_BiuClient, room, name string) {
client.Name = name
client.Program.Send(systemMsg("Server ready!"))
stream.Send(&proto.SignalingMessage{
Room: room,
Sender: name,
Sender: client.Name,
Message: &proto.SignalingMessage_DiscoverRequest{},
})
}
func (client *SignalClient) OnDiscoverRequest(ctx context.Context, stream proto.Signaling_BiuClient, room, name, sender string) {
func (client *SignalClient) OnDiscoverRequest(ctx context.Context, stream proto.Signaling_BiuClient, room, sender string) {
client.Program.Send(systemMsg("Client " + sender + " is joining into the room " + room))
stream.Send(&proto.SignalingMessage{
Room: room,
Sender: name,
Sender: client.Name,
Receiver: &sender,
Message: &proto.SignalingMessage_DiscoverResponse{},
})
}
func (client *SignalClient) OnDiscoverResponse(ctx context.Context, stream proto.Signaling_BiuClient, room, name, sender string) {
func (client *SignalClient) OnDiscoverResponse(ctx context.Context, stream proto.Signaling_BiuClient, room, sender string) {
client.Program.Send(systemMsg("Client " + sender + " ponged"))
peerConnection, err := client.GetOrCreatePeerConnection(sender)
@ -302,19 +319,19 @@ func (client *SignalClient) OnDiscoverResponse(ctx context.Context, stream proto
stream.Send(&proto.SignalingMessage{
Room: room,
Sender: name,
Sender: client.Name,
Receiver: &sender,
Message: &proto.SignalingMessage_SessionOffer{
SessionOffer: &proto.SDPMessage{
SDP: buffer.String(),
Type: proto.SDPMessageType_Data,
Sender: name,
Sender: client.Name,
},
},
})
}
func (client *SignalClient) OnOffer(ctx context.Context, stream proto.Signaling_BiuClient, room, name, sender, sdp string) {
func (client *SignalClient) OnOffer(ctx context.Context, stream proto.Signaling_BiuClient, room, sender, sdp string) {
client.Program.Send(systemMsg("Client " + sender + " is offering"))
peerConnection, err := client.GetOrCreatePeerConnection(sender)
@ -346,13 +363,13 @@ func (client *SignalClient) OnOffer(ctx context.Context, stream proto.Signaling_
stream.Send(&proto.SignalingMessage{
Room: room,
Sender: name,
Sender: client.Name,
Receiver: &sender,
Message: &proto.SignalingMessage_SessionAnswer{
SessionAnswer: &proto.SDPMessage{
SDP: buffer.String(),
Type: proto.SDPMessageType_Data,
Sender: name,
Sender: client.Name,
},
},
})
@ -439,18 +456,29 @@ func (client *SignalClient) SetupDataChannel(pc *webrtc.PeerConnection, dc *webr
})
}
var (
serverUrl string
serverRoom string
iceServers []string
cmd = &cobra.Command{
Run: func(cmd *cobra.Command, args []string) {
signalClient := New(serverUrl, serverRoom, iceServers)
signalClient.Program = tea.NewProgram(signalClient)
if _, err := signalClient.Program.Run(); err != nil {
panic("err")
}
},
}
)
func main() {
flag.Parse()
cmd.Flags().StringVar(&serverUrl, "server", "https://chat.jeffthecoder.xyz", "")
cmd.Flags().StringVar(&serverRoom, "room", "public", "")
cmd.Flags().StringSliceVar(&iceServers, "ice-servers", []string{"stun:nhz.jeffthecoder.xyz:3478", "stun:nhz.jeffthecoder.xyz:3479"}, "")
if flag.NArg() != 2 {
panic("invalid usage")
}
signalClient := New(flag.Arg(0), flag.Arg(1))
signalClient.Program = tea.NewProgram(signalClient)
if _, err := signalClient.Program.Run(); err != nil {
panic("err")
}
cmd.Execute()
}

51
cmd/signal-server/main.go
View File

@ -3,29 +3,44 @@ package main
import (
"log"
"net"
"time"
signal_server "git.jeffthecoder.xyz/public/chat-signaling-server/pkg/impl/signal-server"
proto "git.jeffthecoder.xyz/public/chat-signaling-server/pkg/proto/signaling"
"github.com/spf13/cobra"
"google.golang.org/grpc"
)
var (
serverAddr string
signalSvrOpt signal_server.Options
cmd = &cobra.Command{
Run: func(cmd *cobra.Command, args []string) {
impl, err := signal_server.New(signalSvrOpt)
if err != nil {
panic(err)
}
listener, err := net.Listen("tcp4", serverAddr)
if err != nil {
panic(err)
}
grpcServer := grpc.NewServer()
proto.RegisterSignalingServer(grpcServer, impl)
log.Println("listening on", serverAddr)
if err := grpcServer.Serve(listener); err != nil {
panic(err)
}
},
}
)
func main() {
impl, err := signal_server.New(signal_server.Options{
RedisServers: []string{"127.0.0.1:6379"},
RedisDatabase: 0,
RedisKeyPrefix: "signaling",
})
if err != nil {
panic(err)
}
listener, err := net.Listen("tcp4", "0.0.0.0:4444")
if err != nil {
panic(err)
}
grpcServer := grpc.NewServer()
proto.RegisterSignalingServer(grpcServer, impl)
log.Println("listening on 4444")
if err := grpcServer.Serve(listener); err != nil {
panic(err)
}
cmd.Flags().StringVar(&serverAddr, "listen", "0.0.0.0:4444", "")
cmd.Flags().StringSliceVar(&signalSvrOpt.RedisServers, "redis-server", []string{"127.0.0.1:6379"}, "")
cmd.Flags().IntVar(&signalSvrOpt.RedisDatabase, "redis-db", 0, "")
cmd.Flags().StringVar(&signalSvrOpt.RedisKeyPrefix, "redis-key-prefix", "signaling", "")
cmd.Flags().Int64Var(&signalSvrOpt.NameRandomSeed, "random-seed", time.Now().Unix(), "")
cmd.Execute()
}