/
service.go
133 lines (118 loc) · 2.74 KB
/
service.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
package matter
import (
"context"
"encoding/json"
"log"
"github.com/davecgh/go-spew/spew"
"github.com/keys-pub/keys"
)
var _ MatterServer = &service{}
type service struct {
UnimplementedMatterServer
client *Client
kr Keyring
}
// Keyring for service.
type Keyring interface {
EdX25519Key(kid keys.ID) (*keys.EdX25519Key, error)
}
// NewService is a service for Matter.
func NewService(client *Client, kr Keyring) MatterServer {
return &service{
client: client,
kr: kr,
}
}
func (s *service) Login(ctx context.Context, req *LoginRequest) (*LoginResponse, error) {
kid, err := keys.ParseID(req.KID)
if err != nil {
return nil, err
}
key, err := s.kr.EdX25519Key(kid)
if err != nil {
return nil, err
}
user, err := s.client.LoginWithKey(ctx, key)
if err != nil {
return nil, err
}
return &LoginResponse{
User: user,
}, nil
}
func (s *service) CreateChannel(ctx context.Context, req *CreateChannelRequest) (*CreateChannelResponse, error) {
channel, err := s.client.CreateChannel(ctx, req.Name, req.TeamID)
if err != nil {
return nil, err
}
return &CreateChannelResponse{
Channel: channel,
}, nil
}
func (s *service) TeamsForUser(ctx context.Context, req *TeamsForUserRequest) (*TeamsForUserResponse, error) {
teams, err := s.client.TeamsForUser(ctx, req.UserID)
if err != nil {
return nil, err
}
return &TeamsForUserResponse{
Teams: teams,
}, nil
}
func (s *service) ChannelsForUser(ctx context.Context, req *ChannelsForUserRequest) (*ChannelsForUserResponse, error) {
channels, err := s.client.ChannelsForUser(ctx, req.UserID, req.TeamID)
if err != nil {
return nil, err
}
return &ChannelsForUserResponse{
Channels: channels,
}, nil
}
func (s *service) Listen(server Matter_ListenServer) error {
wsClient, err := s.client.NewWebSocketClient()
if err != nil {
return err
}
defer wsClient.Close()
wsClient.Listen()
go func() {
for {
logger.Debugf("Matter recv...")
req, err := server.Recv()
if err != nil {
wsClient.Close()
return
}
logger.Debugf("Matter recv req: %+v", req)
// wsClient.SendMessage("", nil)
}
}()
for {
select {
case event := <-wsClient.EventChannel:
logger.Debugf(spew.Sdump(event))
if event.Event == "posted" {
postData, ok := event.Data["post"]
if !ok {
continue
}
var post Post
if err := json.Unmarshal(postData.([]byte), &post); err != nil {
log.Printf("Unrecognized post data\n")
continue
}
if err := server.Send(&ListenEvent{
Post: &post,
}); err != nil {
return err
}
}
case resp := <-wsClient.ResponseChannel:
logger.Debugf(spew.Sdump(resp))
case _ = <-wsClient.PingTimeoutChannel:
logger.Warningf("Matter websocket timed out")
return nil
default:
return nil
}
}
}