]> git.r.bdr.sh - rbdr/mobius/blame - server_test.go
git.r.bdr.sh / rbdr / mobius / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
patch: bump version to v0.0.5
[rbdr/mobius] / server_test.go
CommitLineData
6988a057
JH		 1package hotline
2
3//
4//import (
5// "bytes"
6// "fmt"
7// "github.com/google/go-cmp/cmp"
8// "io/ioutil"
9// "math/big"
10// "net"
11// "strings"
12// "sync"
13// "testing"
14//)
15//
16//type transactionTest struct {
17// description string // Human understandable description
18// account Account // Account struct for a user that will test transaction will execute under
19// request Transaction // transaction that will be sent by the client to the server
20// want Transaction // transaction that the client expects to receive in response
21// setup func() // Optional setup required for the test scenario
22// teardown func() // Optional teardown for test scenario
23//}
24//
25//func (tt *transactionTest) Setup(srv *Server) error {
26// if err := srv.NewUser(tt.account.Login, tt.account.Name, NegatedUserString([]byte(tt.account.Password)), tt.account.Access); err != nil {
27// return err
28// }
29//
30// if tt.setup != nil {
31// tt.setup()
32// }
33//
34// return nil
35//}
36//
37//func (tt *transactionTest) Teardown(srv *Server) error {
38// if err := srv.DeleteUser(tt.account.Login); err != nil {
39// return err
40// }
41//
42// if tt.teardown != nil {
43// tt.teardown()
44// }
45//
46// return nil
47//}
48//
49//// StartTestServer
50//func StartTestServer() (srv *Server, lnPort int) {
51// hotlineServer, _ := NewServer("test/config/")
52// ln, err := net.Listen("tcp", ":0")
53//
54// if err != nil {
55// panic(err)
56// }
57// go func() {
58// for {
59// conn, _ := ln.Accept()
60// go hotlineServer.HandleConnection(conn)
61// }
62// }()
63// return hotlineServer, ln.Addr().(*net.TCPAddr).Port
64//}
65//
66//func StartTestClient(serverPort int, login, passwd string) (*Client, error) {
67// c := NewClient("")
68//
69// err := c.JoinServer(fmt.Sprintf(":%v", serverPort), login, passwd)
70// if err != nil {
71// return nil, err
72// }
73//
74// return c, nil
75//}
76//
77//func StartTestServerWithClients(clientCount int) ([]*Client, int) {
78// _, serverPort := StartTestServer()
79//
80// var clients []*Client
81// for i := 0; i < clientCount; i++ {
82// client, err := StartTestClient(serverPort, "admin", "")
83// if err != nil {
84// panic(err)
85// }
86// clients = append(clients, client)
87// }
88// clients[0].ReadN(2)
89//
90// return clients, serverPort
91//}
92//
93
94
95////func TestHandleTranAgreed(t *testing.T) {
96//// clients, _ := StartTestServerWithClients(2)
97////
98//// chatMsg := "Test Chat"
99////
100//// // Assert that both clients should receive the user join notification
101//// var wg sync.WaitGroup
102//// for _, client := range clients {
103//// wg.Add(1)
104//// go func(wg *sync.WaitGroup, c *Client) {
105//// defer wg.Done()
106////
107//// receivedMsg := c.ReadTransactions()[0].GetField(fieldData).Data
108////
109//// want := []byte(fmt.Sprintf("test: %s\r", chatMsg))
110//// if bytes.Compare(receivedMsg, want) != 0 {
111//// t.Errorf("%q, want %q", receivedMsg, want)
112//// }
113//// }(&wg, client)
114//// }
115////
116//// trans := clients[1].ReadTransactions()
117//// spew.Dump(trans)
118////
119//// // Send the agreement
120//// clients[1].Connection.Write(
121//// NewTransaction(
122//// tranAgreed, 0,
123//// []Field{
124//// NewField(fieldUserName, []byte("testUser")),
125//// NewField(fieldUserIconID, []byte{0x00,0x07}),
126//// },
127//// ).Payload(),
128//// )
129////
130//// wg.Wait()
131////}
132//
133//func TestChatSend(t *testing.T) {
134// //srvPort := StartTestServer()
135// //
136// //senderClient := NewClient("senderClient")
137// //senderClient.JoinServer(fmt.Sprintf(":%v", srvPort), "", "")
138// //
139// //receiverClient := NewClient("receiverClient")
140// //receiverClient.JoinServer(fmt.Sprintf(":%v", srvPort), "", "")
141//
142// clients, _ := StartTestServerWithClients(2)
143//
144// chatMsg := "Test Chat"
145//
146// // Both clients should receive the chatMsg
147// var wg sync.WaitGroup
148// for _, client := range clients {
149// wg.Add(1)
150// go func(wg *sync.WaitGroup, c *Client) {
151// defer wg.Done()
152//
153// receivedMsg := c.ReadTransactions()[0].GetField(fieldData).Data
154//
155// want := []byte(fmt.Sprintf(" test: %s\r", chatMsg))
156// if bytes.Compare(receivedMsg, want) != 0 {
157// t.Errorf("%q, want %q", receivedMsg, want)
158// }
159// }(&wg, client)
160// }
161//
162// // Send the chatMsg
163// clients[1].Send(
164// NewTransaction(
165// tranChatSend, 0,
166// []Field{
167// NewField(fieldData, []byte(chatMsg)),
168// },
169// ),
170// )
171//
172// wg.Wait()
173//}
174//
175//func TestSetClientUserInfo(t *testing.T) {
176// clients, _ := StartTestServerWithClients(2)
177//
178// newIcon := []byte{0x00, 0x01}
179// newUserName := "newName"
180//
181// // Both clients should receive the chatMsg
182// var wg sync.WaitGroup
183// for _, client := range clients {
184// wg.Add(1)
185// go func(wg *sync.WaitGroup, c *Client) {
186// defer wg.Done()
187//
188// tran := c.ReadTransactions()[0]
189//
190// want := []byte(newUserName)
191// got := tran.GetField(fieldUserName).Data
192// if bytes.Compare(got, want) != 0 {
193// t.Errorf("%q, want %q", got, want)
194// }
195// }(&wg, client)
196// }
197//
198// _, err := clients[1].Connection.Write(
199// NewTransaction(
200// tranSetClientUserInfo, 0,
201// []Field{
202// NewField(fieldUserIconID, newIcon),
203// NewField(fieldUserName, []byte(newUserName)),
204// },
205// ).Payload(),
206// )
207// if err != nil {
208// t.Errorf("%v", err)
209// }
210//
211// wg.Wait()
212//}
213//
214//// TestSendInstantMsg tests that client A can send an instant message to client B
215////
216//func TestSendInstantMsg(t *testing.T) {
217// clients, _ := StartTestServerWithClients(2)
218//
219// instantMsg := "Test IM"
220//
221// var wg sync.WaitGroup
222// wg.Add(1)
223// go func(wg *sync.WaitGroup, c *Client) {
224// defer wg.Done()
225//
226// tran := c.WaitForTransaction(tranServerMsg)
227//
228// receivedMsg := tran.GetField(fieldData).Data
229// want := []byte(fmt.Sprintf("%s", instantMsg))
230// if bytes.Compare(receivedMsg, want) != 0 {
231// t.Errorf("%q, want %q", receivedMsg, want)
232// }
233// }(&wg, clients[0])
234//
235// _ = clients[1].Send(
236// NewTransaction(tranGetUserNameList, 0, []Field{}),
237// )
238// //connectedUsersTran := clients[1].ReadTransactions()[0]
239// ////connectedUsers := connectedUsersTran.Fields[0].Data[0:2]
240// //spew.Dump(connectedUsersTran.Fields)
241// //firstUserID := connectedUsersTran.Fields[0].Data[0:2]
242// //
243// //spew.Dump(firstUserID)
244//
245// // Send the IM
246// err := clients[1].Send(
247// NewTransaction(
248// tranSendInstantMsg, 0,
249// []Field{
250// NewField(fieldData, []byte(instantMsg)),
251// NewField(fieldUserName, clients[1].UserName),
252// NewField(fieldUserID, []byte{0, 2}),
253// NewField(fieldOptions, []byte{0, 1}),
254// },
255// ),
256// )
257// if err != nil {
258// t.Error(err)
259// }
260//
261// wg.Wait()
262//}
263//
264//func TestOldPostNews(t *testing.T) {
265// clients, _ := StartTestServerWithClients(2)
266//
267// newsPost := "Test News Post"
268//
269// var wg sync.WaitGroup
270// wg.Add(1)
271// go func(wg *sync.WaitGroup, c *Client) {
272// defer wg.Done()
273//
274// receivedMsg := c.ReadTransactions()[0].GetField(fieldData).Data
275//
276// if strings.Contains(string(receivedMsg), newsPost) == false {
277// t.Errorf("news post missing")
278// }
279// }(&wg, clients[0])
280//
281// clients[1].Connection.Write(
282// NewTransaction(
283// tranOldPostNews, 0,
284// []Field{
285// NewField(fieldData, []byte(newsPost)),
286// },
287// ).Payload(),
288// )
289//
290// wg.Wait()
291//}
292//
293//// TODO: Fixme
294////func TestGetFileNameList(t *testing.T) {
295//// clients, _ := StartTestServerWithClients(2)
296////
297//// clients[0].Connection.Write(
298//// NewTransaction(
299//// tranGetFileNameList, 0,
300//// []Field{},
301//// ).Payload(),
302//// )
303////
304//// ts := clients[0].ReadTransactions()
305//// testfileSit := ReadFileNameWithInfo(ts[0].Fields[1].Data)
306////
307//// want := "testfile.sit"
308//// got := testfileSit.Name
309//// diff := cmp.Diff(want, got)
310//// if diff != "" {
311//// t.Fatalf(diff)
312//// }
313//// if testfileSit.Name != "testfile.sit" {
314//// t.Errorf("news post missing")
315//// t.Errorf("%q, want %q", testfileSit.Name, "testfile.sit")
316//// }
317////}
318//
319//func TestNewsCategoryList(t *testing.T) {
320// clients, _ := StartTestServerWithClients(2)
321// client := clients[0]
322//
323// client.Send(
324// NewTransaction(
325// tranGetNewsCatNameList, 0,
326// []Field{},
327// ),
328// )
329//
330// ts := client.ReadTransactions()
331// cats := ts[0].GetFields(fieldNewsCatListData15)
332//
333// newsCat := ReadNewsCategoryListData(cats[0].Data)
334// want := "TestBundle"
335// got := newsCat.Name
336// diff := cmp.Diff(want, got)
337// if diff != "" {
338// t.Fatalf(diff)
339// }
340//
341// newsBundle := ReadNewsCategoryListData(cats[1].Data)
342// want = "TestCat"
343// got = newsBundle.Name
344// diff = cmp.Diff(want, got)
345// if diff != "" {
346// t.Fatalf(diff)
347// }
348//}
349//
350//func TestNestedNewsCategoryList(t *testing.T) {
351// clients, _ := StartTestServerWithClients(2)
352// client := clients[0]
353// newsPath := NewsPath{
354// []string{
355// "TestBundle",
356// "NestedBundle",
357// },
358// }
359//
360// _, err := client.Connection.Write(
361// NewTransaction(
362// tranGetNewsCatNameList, 0,
363// []Field{
364// NewField(
365// fieldNewsPath,
366// newsPath.Payload(),
367// ),
368// },
369// ).Payload(),
370// )
371// if err != nil {
372// t.Errorf("%v", err)
373// }
374//
375// ts := client.ReadTransactions()
376// cats := ts[0].GetFields(fieldNewsCatListData15)
377//
378// newsCat := ReadNewsCategoryListData(cats[0].Data)
379// want := "NestedCat"
380// got := newsCat.Name
381// diff := cmp.Diff(want, got)
382// if diff != "" {
383// t.Fatalf(diff)
384// }
385//}
386//
387//func TestFileDownload(t *testing.T) {
388// clients, _ := StartTestServerWithClients(2)
389// client := clients[0]
390//
391// type want struct {
392// fileSize []byte
393// transferSize []byte
394// waitingCount []byte
395// refNum []byte
396// }
397// var tests = []struct {
398// fileName string
399// want want
400// }{
401// {
402// fileName: "testfile.sit",
403// want: want{
404// fileSize: []byte{0x0, 0x0, 0x0, 0x13},
405// transferSize: []byte{0x0, 0x0, 0x0, 0xa1},
406// },
407// },
408// {
409// fileName: "testfile.txt",
410// want: want{
411// fileSize: []byte{0x0, 0x0, 0x0, 0x17},
412// transferSize: []byte{0x0, 0x0, 0x0, 0xa5},
413// },
414// },
415// }
416//
417// for _, test := range tests {
418// _, err := client.Connection.Write(
419// NewTransaction(
420// tranDownloadFile, 0,
421// []Field{
422// NewField(fieldFileName, []byte(test.fileName)),
423// NewField(fieldFilePath, []byte("")),
424// },
425// ).Payload(),
426// )
427// if err != nil {
428// t.Errorf("%v", err)
429// }
430// tran := client.ReadTransactions()[0]
431//
432// if got := tran.GetField(fieldFileSize).Data; bytes.Compare(got, test.want.fileSize) != 0 {
433// t.Errorf("TestFileDownload: fileSize got %#v, want %#v", got, test.want.fileSize)
434// }
435//
436// if got := tran.GetField(fieldTransferSize).Data; bytes.Compare(got, test.want.transferSize) != 0 {
437// t.Errorf("TestFileDownload: fieldTransferSize: %s: got %#v, want %#v", test.fileName, got, test.want.transferSize)
438// }
439// }
440//}
441//
442//func TestFileUpload(t *testing.T) {
443// clients, _ := StartTestServerWithClients(2)
444// client := clients[0]
445//
446// var tests = []struct {
447// fileName string
448// want Transaction
449// }{
450// {
451// fileName: "testfile.sit",
452// want: Transaction{
453// Fields: []Field{
454// NewField(fieldRefNum, []byte{0x16, 0x3f, 0x5f, 0xf}),
455// },
456// },
457// },
458// }
459//
460// for _, test := range tests {
461// err := client.Send(
462// NewTransaction(
463// tranUploadFile, 0,
464// []Field{
465// NewField(fieldFileName, []byte(test.fileName)),
466// NewField(fieldFilePath, []byte("")),
467// },
468// ),
469// )
470// if err != nil {
471// t.Errorf("%v", err)
472// }
473// tran := client.ReadTransactions()[0]
474//
475// for _, f := range test.want.Fields {
476// got := tran.GetField(f.Uint16ID()).Data
477// want := test.want.GetField(fieldRefNum).Data
478// if bytes.Compare(got, want) != 0 {
479// t.Errorf("xxx: yyy got %#v, want %#v", got, want)
480// }
481// }
482// }
483//}
484//
485//// TODO: Make canonical
486//func TestNewUser(t *testing.T) {
487// srv, port := StartTestServer()
488//
489// var tests = []struct {
490// description string
491// setup func()
492// teardown func()
493// account Account
494// request Transaction
495// want Transaction
496// }{
497// {
498// description: "a valid new account",
499// teardown: func() {
500// _ = srv.DeleteUser("testUser")
501// },
502// account: Account{
503// Login: "test",
504// Name: "unnamed",
505// Password: "test",
506// Access: []byte{255, 255, 255, 255, 255, 255, 255, 255},
507// },
508// request: NewTransaction(
509// tranNewUser, 0,
510// []Field{
511// NewField(fieldUserLogin, []byte(NegatedUserString([]byte("testUser")))),
512// NewField(fieldUserName, []byte("testUserName")),
513// NewField(fieldUserPassword, []byte(NegatedUserString([]byte("testPw")))),
514// NewField(fieldUserAccess, []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}),
515// },
516// ),
517// want: Transaction{
518// Fields: []Field{},
519// },
520// },
521// {
522// description: "a newUser request from a user without the required access",
523// teardown: func() {
524// _ = srv.DeleteUser("testUser")
525// },
526// account: Account{
527// Login: "test",
528// Name: "unnamed",
529// Password: "test",
530// Access: []byte{0, 0, 0, 0, 0, 0, 0, 0},
531// },
532// request: NewTransaction(
533// tranNewUser, 0,
534// []Field{
535// NewField(fieldUserLogin, []byte(NegatedUserString([]byte("testUser")))),
536// NewField(fieldUserName, []byte("testUserName")),
537// NewField(fieldUserPassword, []byte(NegatedUserString([]byte("testPw")))),
538// NewField(fieldUserAccess, []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}),
539// },
540// ),
541// want: Transaction{
542// Fields: []Field{
543// NewField(fieldError, []byte("You are not allowed to create new accounts.")),
544// },
545// },
546// },
547// {
548// description: "a request to create a user that already exists",
549// teardown: func() {
550// _ = srv.DeleteUser("testUser")
551// },
552// account: Account{
553// Login: "test",
554// Name: "unnamed",
555// Password: "test",
556// Access: []byte{255, 255, 255, 255, 255, 255, 255, 255},
557// },
558// request: NewTransaction(
559// tranNewUser, 0,
560// []Field{
561// NewField(fieldUserLogin, []byte(NegatedUserString([]byte("guest")))),
562// NewField(fieldUserName, []byte("testUserName")),
563// NewField(fieldUserPassword, []byte(NegatedUserString([]byte("testPw")))),
564// NewField(fieldUserAccess, []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}),
565// },
566// ),
567// want: Transaction{
568// Fields: []Field{
569// NewField(fieldError, []byte("Cannot create account guest because there is already an account with that login.")),
570// },
571// },
572// },
573// }
574//
575// for _, test := range tests {
576// if test.setup != nil {
577// test.setup()
578// }
579//
580// if err := srv.NewUser(test.account.Login, test.account.Name, NegatedUserString([]byte(test.account.Password)), test.account.Access); err != nil {
581// t.Errorf("%v", err)
582// }
583//
584// c := NewClient("")
585// err := c.JoinServer(fmt.Sprintf(":%v", port), test.account.Login, test.account.Password)
586// if err != nil {
587// t.Errorf("login failed: %v", err)
588// }
589//
590// if err := c.Send(test.request); err != nil {
591// t.Errorf("%v", err)
592// }
593//
594// tran := c.ReadTransactions()[0]
595// for _, want := range test.want.Fields {
596// got := tran.GetField(want.Uint16ID())
597// if bytes.Compare(got.Data, want.Data) != 0 {
598// t.Errorf("%v: field mismatch: want: %#v got: %#v", test.description, want.Data, got.Data)
599// }
600// }
601//
602// srv.DeleteUser(test.account.Login)
603//
604// if test.teardown != nil {
605// test.teardown()
606// }
607// }
608//}
609//
610//func TestDeleteUser(t *testing.T) {
611// srv, port := StartTestServer()
612//
613// var tests = []transactionTest{
614// {
615// description: "a deleteUser request from a user without the required access",
616// account: Account{
617// Login: "test",
618// Name: "unnamed",
619// Password: "test",
620// Access: []byte{0, 0, 0, 0, 0, 0, 0, 0},
621// },
622// request: NewTransaction(
623// tranDeleteUser, 0,
624// []Field{
625// NewField(fieldUserLogin, []byte(NegatedUserString([]byte("foo")))),
626// },
627// ),
628// want: Transaction{
629// Fields: []Field{
630// NewField(fieldError, []byte("You are not allowed to delete accounts.")),
631// },
632// },
633// },
634// {
635// description: "a valid deleteUser request",
636// setup: func() {
637// _ = srv.NewUser("foo", "foo", "foo", []byte{0, 0, 0, 0, 0, 0, 0, 0})
638// },
639// account: Account{
640// Login: "test",
641// Name: "unnamed",
642// Password: "test",
643// Access: []byte{255, 255, 255, 255, 255, 255, 255, 255},
644// },
645// request: NewTransaction(
646// tranDeleteUser, 0,
647// []Field{
648// NewField(fieldUserLogin, []byte(NegatedUserString([]byte("foo")))),
649// },
650// ),
651// want: Transaction{
652// Fields: []Field{},
653// },
654// },
655// }
656//
657// for _, test := range tests {
658// test.Setup(srv)
659//
660// c := NewClient("")
661// err := c.JoinServer(fmt.Sprintf(":%v", port), test.account.Login, test.account.Password)
662// if err != nil {
663// t.Errorf("login failed: %v", err)
664// }
665//
666// if err := c.Send(test.request); err != nil {
667// t.Errorf("%v", err)
668// }
669//
670// tran := c.ReadTransactions()[0]
671// for _, want := range test.want.Fields {
672// got := tran.GetField(want.Uint16ID())
673// if bytes.Compare(got.Data, want.Data) != 0 {
674// t.Errorf("%v: field mismatch: want: %#v got: %#v", test.description, want.Data, got.Data)
675// }
676// }
677//
678// test.Teardown(srv)
679// }
680//}
681//
682//func TestDeleteFile(t *testing.T) {
683// srv, port := StartTestServer()
684//
685// var tests = []transactionTest{
686// {
687// description: "a request without the required access",
688// account: Account{
689// Login: "test",
690// Name: "unnamed",
691// Password: "test",
692// Access: []byte{0, 0, 0, 0, 0, 0, 0, 0},
693// },
694// request: NewTransaction(
695// tranDeleteFile, 0,
696// []Field{
697// NewField(fieldFileName, []byte("testFile")),
698// NewField(fieldFilePath, []byte("")),
699// },
700// ),
701// want: Transaction{
702// Fields: []Field{},
703// },
704// },
705// {
706// description: "a valid deleteFile request",
707// setup: func() {
708// _ = ioutil.WriteFile(srv.Config.FileRoot+"testFile", []byte{0x00}, 0666)
709// },
710// account: Account{
711// Login: "test",
712// Name: "unnamed",
713// Password: "test",
714// Access: []byte{255, 255, 255, 255, 255, 255, 255, 255},
715// },
716// request: NewTransaction(
717// tranDeleteFile, 0,
718// []Field{
719// NewField(fieldFileName, []byte("testFile")),
720// NewField(fieldFilePath, []byte("")),
721// },
722// ),
723// want: Transaction{
724// Fields: []Field{},
725// },
726// },
727// {
728// description: "an invalid request for a file that does not exist",
729// account: Account{
730// Login: "test",
731// Name: "unnamed",
732// Password: "test",
733// Access: []byte{255, 255, 255, 255, 255, 255, 255, 255},
734// },
735// request: NewTransaction(
736// tranDeleteFile, 0,
737// []Field{
738// NewField(fieldFileName, []byte("testFile")),
739// NewField(fieldFilePath, []byte("")),
740// },
741// ),
742// want: Transaction{
743// Fields: []Field{
744// NewField(fieldError, []byte("Cannot delete file testFile because it does not exist or cannot be found.")),
745// },
746// },
747// },
748// }
749//
750// for _, test := range tests {
751// test.Setup(srv)
752//
753// c := NewClient("")
754//
755// if err := c.JoinServer(fmt.Sprintf(":%v", port), test.account.Login, test.account.Password); err != nil {
756// t.Errorf("login failed: %v", err)
757// }
758//
759// if err := c.Send(test.request); err != nil {
760// t.Errorf("%v", err)
761// }
762//
763// tran := c.ReadTransactions()[0]
764// for _, want := range test.want.Fields {
765// got := tran.GetField(want.Uint16ID())
766// if bytes.Compare(got.Data, want.Data) != 0 {
767// t.Errorf("%v: field mismatch: want: %#v got: %#v", test.description, want.Data, got.Data)
768// }
769// }
770//
771// test.Teardown(srv)
772// }
773//}
774//
775//func Test_authorize(t *testing.T) {
776// accessBitmap := big.NewInt(int64(0))
777// accessBitmap.SetBit(accessBitmap, accessCreateFolder, 1)
778// fmt.Printf("%v %b %x\n", accessBitmap, accessBitmap, accessBitmap)
779// fmt.Printf("%b\n", 0b10000)
780//
781// type args struct {
782// access *[]byte
783// reqAccess int
784// }
785// tests := []struct {
786// name string
787// args args
788// want bool
789// }{
790// {
791// name: "fooz",
792// args: args{
793// access: &[]byte{4, 0, 0, 0, 0, 0, 0, 0x02},
794// reqAccess: accessDownloadFile,
795// },
796// want: true,
797// },
798// }
799// for _, tt := range tests {
800// t.Run(tt.name, func(t *testing.T) {
801// if got := authorize(tt.args.access, tt.args.reqAccess); got != tt.want {
802// t.Errorf("authorize() = %v, want %v", got, tt.want)
803// }
804// })
805// }
806//}
Friendship Quest remix of mobius, a hotline server in go #cli