1
1
package main
2
2
3
3
import (
4
- "compress/gzip"
5
4
"csgo-2d-demo-player/conf"
6
- "csgo-2d-demo-player/pkg/auth"
7
- "csgo-2d-demo-player/pkg/list"
8
5
"csgo-2d-demo-player/pkg/log"
9
- "csgo-2d-demo-player/pkg/message"
10
- "csgo-2d-demo-player/pkg/parser"
11
6
"csgo-2d-demo-player/pkg/provider/faceit"
12
7
"csgo-2d-demo-player/pkg/provider/steam"
13
- "encoding/json"
14
8
"fmt"
15
- "io"
16
9
"net/http"
17
10
18
11
"github.com/alexflint/go-arg"
19
- "github.com/gorilla/websocket"
20
- "github.com/markus-wa/demoinfocs-golang/v3/pkg/demoinfocs"
21
12
"go.uber.org/zap"
22
- "google.golang.org/protobuf/proto"
23
13
)
24
14
25
15
var config * conf.Conf
@@ -34,213 +24,16 @@ func main() {
34
24
defer log .Close ()
35
25
36
26
log .L ().Debug ("using config" , zap .Any ("config" , config ))
37
- faceitClient = faceit .NewFaceitClient (config )
38
- steamClient = steam .NewSteamClient (config )
39
- // log.Printf("using config %+v", config)
40
27
server ()
41
28
}
42
29
43
- func handleMessages (in chan []byte , out chan []byte ) {
44
- for msg := range in {
45
- var messageObj message.Message
46
- err := json .Unmarshal (msg , & messageObj )
47
- if err != nil {
48
- log .Print ("failed unmarshal websocket message" , err )
49
- }
50
- switch messageObj .MsgType {
51
- case message .Message_PlayRequestType :
52
- go playDemo (out , messageObj .Demo .MatchId )
53
- }
54
- }
55
- }
56
-
57
30
func server () {
58
31
mux := http .NewServeMux ()
59
32
60
33
mux .Handle ("/assets/" , http .StripPrefix ("/assets" , http .FileServer (http .Dir ("./assets" ))))
61
34
mux .Handle ("/" , http .FileServer (http .Dir ("web/index/build" )))
62
- mux .Handle ("/player/" , http .StripPrefix ("/player" , http .FileServer (http .Dir ("web/player/build" ))))
63
-
64
- listService := list.ListService {
65
- Conf : config ,
66
- FaceitClient : faceitClient ,
67
- }
68
- mux .HandleFunc ("/match/list" , listService .ListMatches )
69
- mux .HandleFunc ("/match/detail" , listService .MatchDetails )
70
-
71
- // faceit auth
72
- mux .HandleFunc ("/auth/faceit/login" , faceitClient .LoginHandler )
73
- mux .HandleFunc ("/auth/faceit/callback" , faceitClient .OAuthCallbackHandler )
74
- mux .HandleFunc ("/auth/faceit/logout" , faceitClient .LogoutHandler )
75
- mux .Handle ("/faceit/api/" , http .StripPrefix ("/faceit/api/" , faceitClient ))
76
-
77
- // steam auth
78
- mux .HandleFunc ("/auth/steam/login" , steamClient .LoginHandler )
79
- mux .HandleFunc ("/auth/steam/callback" , steamClient .OAuthCallbackHandler )
80
- mux .HandleFunc ("/auth/steam/logout" , steamClient .LogoutHandler )
81
-
82
- mux .HandleFunc ("/auth/whoami" , func (w http.ResponseWriter , r * http.Request ) {
83
- if config .Mode == conf .MODE_DEV {
84
- w .Header ().Set ("Access-Control-Allow-Origin" , r .Header .Get ("Origin" ))
85
- w .Header ().Set ("Access-Control-Allow-Credentials" , "true" )
86
- }
87
-
88
- faceitAuth , err := auth .GetAuthCookie (faceit .FaceitAuthCookieName , r , & auth.FaceitAuthInfo {})
89
- if err != nil {
90
- log .L ().Info ("some error getting the cookie, why???" , zap .Error (err ))
91
- // http.Error(writer, err.Error(), 500)
92
- }
93
- // log.L().Info("cookie", zap.Any("cok", authCookie))
94
- type whoamiInfo struct {
95
- FaceitNickname string `json:"faceitNickname,omitempty"`
96
- FaceitGuid string `json:"faceitGuid,omitempty"`
97
- SteamId string `json:"steamId,omitempty"`
98
- SteamName string `json:"steamUsername,omitempty"`
99
- SteamAvatar string `json:"steamAvatar,omitempty"`
100
- }
101
- whoami := whoamiInfo {}
102
- if faceitAuth != nil {
103
- whoami .FaceitNickname = faceitAuth .UserInfo .Nickname
104
- whoami .FaceitGuid = faceitAuth .UserInfo .Guid
105
- }
106
-
107
- steamAuth , err := auth .GetAuthCookie (steam .SteamAuthCookieName , r , & auth.SteamAuthInfo {})
108
- if err != nil {
109
- log .L ().Info ("some error getting the cookie, why???" , zap .Error (err ))
110
- // http.Error(writer, err.Error(), 500)
111
- }
112
- if steamAuth != nil {
113
- whoami .SteamId = steamAuth .UserId
114
- whoami .SteamName = steamAuth .Username
115
- whoami .SteamAvatar = steamAuth .AvatarUrl
116
- }
117
-
118
- if whoamiJson , errMarshal := json .Marshal (whoami ); errMarshal != nil {
119
- log .L ().Error ("failed to marshall whoami info" , zap .Error (errMarshal ))
120
- } else {
121
- _ , errWrite := w .Write (whoamiJson )
122
- if errWrite != nil {
123
- log .L ().Error ("failed to write response" , zap .Error (errWrite ))
124
- w .WriteHeader (http .StatusServiceUnavailable )
125
- }
126
- }
127
- })
128
-
129
- mux .HandleFunc ("/ws" , func (writer http.ResponseWriter , request * http.Request ) {
130
- // Upgrade our raw HTTP connection to a websocket based one
131
- upgrader := websocket.Upgrader {}
132
- if request .Host == "localhost:8080" {
133
- upgrader .CheckOrigin = func (r * http.Request ) bool {
134
- return true
135
- }
136
- }
137
- conn , err := upgrader .Upgrade (writer , request , nil )
138
- if err != nil {
139
- log .Print ("Error during connection upgradation:" , err )
140
- return
141
- }
142
-
143
- out := make (chan []byte )
144
- in := make (chan []byte )
145
- go handleMessages (in , out )
146
-
147
- // out routine
148
- go func () {
149
- defer func () {
150
- if closeErr := conn .Close (); closeErr != nil {
151
- log .Printf ("failed to close connection [out] '%s'" , closeErr .Error ())
152
- }
153
- }()
154
-
155
- for msg := range out {
156
- err = conn .WriteMessage (websocket .BinaryMessage , msg )
157
- if err != nil {
158
- log .Println ("Error during message writing:" , err )
159
- break
160
- }
161
- }
162
- }()
163
-
164
- // in routine
165
- go func () {
166
- defer func () {
167
- if closeErr := conn .Close (); closeErr != nil {
168
- log .Printf ("failed to close connection [in] '%s'" , closeErr .Error ())
169
- }
170
- }()
171
-
172
- for {
173
- _ , msg , err := conn .ReadMessage ()
174
- if err != nil {
175
- closeErr , isCloseErr := err .(* websocket.CloseError )
176
- if ! isCloseErr || closeErr .Code != websocket .CloseGoingAway {
177
- log .Println ("Error during message reading: " , err )
178
- }
179
- break
180
- }
181
- in <- msg
182
- }
183
- }()
184
- })
185
35
log .L ().Info ("HTTP server listening on ..." , zap .String ("listen" , config .Listen ), zap .Int ("port" , config .Port ))
186
36
// log.Println("Listening on ", config.Port, " ...")
187
37
listenErr := http .ListenAndServe (fmt .Sprintf ("%s:%d" , config .Listen , config .Port ), mux )
188
38
log .L ().Fatal ("failed to listen" , zap .Error (listenErr ))
189
39
}
190
-
191
- func playDemo (out chan []byte , matchId string ) {
192
- log .L ().Info ("playing faceit demo" , zap .String ("matchId" , matchId ))
193
- if matchId == "" {
194
- sendError ("no matchId" , out )
195
- return
196
- }
197
- demoFile , closers , err := obtainDemoFile (matchId )
198
- if err != nil {
199
- sendError (err .Error (), out )
200
- return
201
- }
202
- defer func () {
203
- for _ , c := range closers {
204
- if closeErr := c .Close (); closeErr != nil {
205
- log .Printf ("[%s] failed to close resource. %s" , matchId , closeErr )
206
- }
207
- }
208
- }()
209
- err = parser .Parse (demoFile , func (msg * message.Message , tick demoinfocs.GameState ) {
210
- sendMessage (msg , out )
211
- })
212
- if err != nil {
213
- sendError (err .Error (), out )
214
- }
215
- }
216
-
217
- func sendMessage (msg * message.Message , out chan []byte ) {
218
- payload , protoErr := proto .Marshal (msg )
219
- if protoErr != nil {
220
- sendError (protoErr .Error (), out )
221
- }
222
- out <- payload
223
- }
224
-
225
- func sendError (errorMessage string , out chan []byte ) {
226
- log .Printf ("sending error to client: '%s'" , errorMessage )
227
- out <- []byte (fmt .Sprintf ("{\" msgType\" : %d, \" error\" : {\" message\" : \" %s\" }}" , message .Message_ErrorType , errorMessage ))
228
- }
229
-
230
- func obtainDemoFile (matchId string ) (io.Reader , []io.Closer , error ) {
231
- closers := make ([]io.Closer , 0 )
232
-
233
- demoFileReader , streamErr := faceitClient .DemoStream (matchId )
234
- if streamErr != nil {
235
- return nil , closers , streamErr
236
- }
237
- closers = append (closers , demoFileReader )
238
-
239
- gzipReader , gzipErr := gzip .NewReader (demoFileReader )
240
- if gzipErr != nil {
241
- log .Printf ("[%s] Failed to create gzip reader from demo. %s" , matchId , gzipErr )
242
- return nil , closers , gzipErr
243
- }
244
- closers = append (closers , gzipReader )
245
- return gzipReader , closers , gzipErr
246
- }
0 commit comments