GO语言练习：channel 工程实例

  1 package main
  2 
  3 import (
  4     "bufio"
  5     "fmt"
  6     "os"
  7     "strconv"
  8     "strings"
  9 
 10     "cg"
 11     "ipc"
 12 )
 13 
 14 var centerClient * cg.CenterClient
 15 
 16 func startCenterService() error {
 17     server := ipc.NewIpcServer(&cg.CenterServer{})
 18     client := ipc.NewIpcClient(server)
 19     centerClient = &cg.CenterClient{client}
 20 
 21     return nil
 22 }
 23 
 24 func Help(args []string) int {
 25     fmt.Println(`
 26     Commands:
 27         login <userbane><level><exp>
 28         logout <username>
 29         send <message>
 30         listplayer
 31         quit(q)
 32         help(h)
 33     `)
 34     return 0
 35 }
 36 
 37 func Quit(args []string) int {
 38     return 1
 39 }
 40 
 41 func Logout(args []string) int {
 42     if len (args) != 2 {
 43         fmt.Println("USAGE: logout <username>")
 44         return 0
 45     }
 46     centerClient.RemovePlayer(args[1])
 47 
 48     return 0
 49 }
 50 
 51 func Login(args []string) int {
 52     if len(args) != 4 {
 53         fmt.Println("USAGE: login <username><level><exp>")
 54         return 0
 55     }
 56 
 57     level, err := strconv.Atoi(args[2])
 58     if err != nil {
 59         fmt.Println("Invaild Parameter : <level> should be an integer.")
 60         return 0
 61     }
 62     exp, err := strconv.Atoi(args[3])
 63     if err != nil {
 64         fmt.Println("Invaild Parameter : <exp> should be an integer.")
 65         return 0
 66     }
 67     player := cg.NewPlayer()
 68     player.Name = args[1]
 69     player.Level = level
 70     player.Exp = exp
 71 
 72     err = centerClient.AddPlayer(player)
 73     if err != nil {
 74         fmt.Println("Faild adding player", err)
 75     }
 76 
 77     return 0
 78 }
 79 
 80 func ListPlayer(args []string) int {
 81     ps , err := centerClient.ListPlayer("")
 82     if err != nil {
 83         fmt.Println("Faild. ", err)
 84     } else {
 85         for i, v := range ps {
 86             fmt.Println(i + 1, ":", v)
 87         }
 88     }
 89     return 0
 90 }
 91 
 92 func Send(args []string) int {
 93     message := strings.Join(args[1:], " ")
 94 
 95     err := centerClient.Broadcast(message)
 96     if err != nil {
 97         fmt.Println("Faild. ", err)
 98     }
 99 
100     return 0
101 }
102 
103 func GetCommandHandlers() map[string] func(args[]string) int {
104     return map[string]func([]string) int {
105         "help"    : Help,
106         "h"        : Help,
107         "quit"    : Quit,
108         "q"        : Quit,
109         "login"    : Login,
110         "logout": Logout,
111         "listplayer": ListPlayer,
112         "send"    : Send,
113     }
114 }
115 
116 func main() {
117     fmt.Println("Casual Game Server Soluion")
118 
119     startCenterService()
120 
121     Help(nil)
122 
123     r := bufio.NewReader(os.Stdin)
124 
125     handlers := GetCommandHandlers()
126 
127     for {
128         fmt.Print("command> ")
129         b, _, _ := r.ReadLine()
130         line := string(b)
131 
132         tokens := strings.Split(line, " ")
133 
134         if handler, ok := handlers[tokens[0]]; ok {
135             ret := handler(tokens)
136             if ret != 0 {
137                 break
138             }
139         } else {
140             fmt.Println("Unknown command : ", tokens[0])
141         }
142     }
143 }

 1 package cg
 2 
 3 import (
 4     "errors"
 5     "encoding/json"
 6 
 7     "ipc"
 8 )
 9 
10 type CenterClient struct {
11     *ipc.IpcClient
12 }
13 
14 func (client * CenterClient)AddPlayer(player * Player)error {
15     b, err := json.Marshal(*player)
16     if err != nil {
17         return err
18     }
19 
20     resp, err := client.Call("addplayer", string(b))
21     if err == nil && resp.Code == "200" {
22         return nil
23     }
24 
25     return err
26 }
27 
28 func (client *CenterClient)RemovePlayer(name string) error {
29     ret, _ := client.Call("removeplayer", name)
30     if ret.Code == "200" {
31         return nil
32     }
33 
34     return errors.New(ret.Code)
35 }
36 
37 func (client * CenterClient)ListPlayer(params string)(ps []*Player, err error) {
38     resp, _ := client.Call("listplayer", params)
39     if resp.Code != "200" {
40         err = errors.New(resp.Code)
41         return
42     }
43 
44     err = json.Unmarshal([]byte(resp.Body), &ps)
45     return
46 }
47 
48 func (client * CenterClient)Broadcast(message string) error {
49     m := &Message{Content:message}
50 
51     b, err := json.Marshal(m)
52     if err != nil {
53         return err
54     }
55     resp, _ := client.Call("broadcast", string(b))
56     if resp.Code == "200" {
57         return nil
58     }
59 
60     return errors.New(resp.Code)
61 }

  1 package cg
  2 
  3 import (
  4     "encoding/json"
  5     "errors"
  6     "sync"
  7 
  8     "ipc"
  9 )
 10 
 11 var _ ipc.Server = &CenterServer{}
 12 
 13 type Message struct {
 14     From string "from"
 15     To string "to"
 16     Content string "content"
 17 }
 18 
 19 type Room struct {
 20 }
 21 
 22 type CenterServer struct {
 23     servers map[string] ipc.Server
 24     players []*Player
 25     rooms []*Room
 26     mutex sync.RWMutex
 27 }
 28 
 29 func NewCenterServer() * CenterServer {
 30     servers := make(map[string] ipc.Server)
 31     players := make([]*Player, 0)
 32     return  &CenterServer{servers:servers, players:players}
 33 }
 34 
 35 func (server * CenterServer)addPlayer(params string) error {
 36     player := NewPlayer()
 37 
 38     err := json.Unmarshal([]byte(params), &player)
 39     if err != nil {
 40         return err
 41     }
 42 
 43     server.mutex.Lock()
 44     defer server.mutex.Unlock()
 45 
 46     server.players = append(server.players, player)
 47 
 48     return nil
 49 }
 50 
 51 func (server * CenterServer)removePlayer(params string) error {
 52     server.mutex.Lock()
 53     defer server.mutex.Unlock()
 54 
 55     for i, v := range server.players {
 56         if v.Name == params {
 57             if len(server.players) == 1 {
 58                 server.players = make([]*Player, 0)
 59             } else if i == len(server.players) - 1 {
 60                 server.players = server.players[:i - 1]
 61             } else if i == 0 {
 62                 server.players = server.players[1:]
 63             } else {
 64                 server.players = append(server.players[:i - 1], server.players[:i + 1]...)
 65             }
 66             return nil
 67         }
 68     }
 69 
 70     return errors.New("Player not found")
 71 }
 72 
 73 func (server * CenterServer)listPlayer(params string)(players string , err error) {
 74     server.mutex.RLock()
 75     defer server.mutex.RUnlock()
 76 
 77     if len(server.players) > 0 {
 78         b, _ := json.Marshal(server.players)
 79         players = string(b)
 80     } else {
 81         err = errors.New("No play online.")
 82     }
 83 
 84     return
 85 }
 86 
 87 func (server * CenterServer)broadCast(params string) error {
 88     var message Message
 89     err := json.Unmarshal([]byte(params), &message)
 90     if err != nil {
 91         return err
 92     }
 93 
 94     server.mutex.Lock()
 95     defer server.mutex.Unlock()
 96 
 97     if len(server.players) > 0 {
 98         for _, player := range server.players {
 99             player.mq <- &message
100         }
101     } else {
102         err = errors.New("No player online.")
103     }
104 
105     return err
106 }
107 
108 func (server * CenterServer)Handle(method, params string) *ipc.Response {
109     switch method {
110     case "addplayer" :
111         err := server.addPlayer(params)
112         if err != nil {
113             return &ipc.Response{Code:err.Error()}
114         }
115     case "removeplayer" :
116         err := server.removePlayer(params)
117         if err != nil {
118             return &ipc.Response{Code:err.Error()}
119         }
120     case "listplayer" :
121         players, err := server.listPlayer(params)
122         if err != nil {
123             return &ipc.Response{Code:err.Error()}
124         }
125         return &ipc.Response{"200", players}
126     case "broadcast" :
127         err := server.broadCast(params)
128         if err != nil {
129             return &ipc.Response{Code:err.Error()}
130         }
131         return &ipc.Response{Code:"200"}
132         default :
133         return &ipc.Response{Code:"404", Body:method + ":" + params}
134     }
135     return &ipc.Response{Code:"200"}
136 }
137 
138 func (server * CenterServer)Name() string {
139     return "CenterServer"
140 }

 1 package cg
 2 
 3 import (
 4     "fmt"
 5 )
 6 
 7 type Player struct {
 8     Name string    "name"
 9     Level int "level"
10     Exp int "exp"
11     Room int "room"
12 
13     mq chan * Message
14 }
15 
16 func NewPlayer() * Player {
17     m := make(chan * Message, 1024)
18     player := &Player{"", 0, 0, 0, m}
19 
20     go func (p * Player) {
21         for {
22             msg := <-p.mq
23             fmt.Println(p.Name, "received message :", msg.Content)
24         }
25     }(player)
26 
27     return player
28 }

 1 package ipc
 2 
 3 import (
 4     "encoding/json"
 5 )
 6 
 7 type IpcClient struct {
 8     conn chan string
 9 }
10 
11 func NewIpcClient(server * IpcServer) * IpcClient {
12     c := server.Connect()
13 
14     return &IpcClient{c}
15 }
16 
17 func (client * IpcClient)Call(method, params string) (resp * Response, err error) {
18     req := &Request{method, params}
19 
20     var b []byte
21     b, err = json.Marshal(req)
22     if err != nil {
23         return
24     }
25 
26     client.conn <- string(b)
27 
28     str := <-client.conn
29 
30     var resp1 Response
31     err = json.Unmarshal([]byte(str), &resp1)
32     resp = &resp1
33 
34     return
35 }
36 
37 func (client * IpcClient)Clsoe() {
38     client.conn <- "CLOSE"
39 }

 1 package ipc
 2 
 3 import (
 4     "testing"
 5 )
 6 
 7 type EchoServer struct {
 8 }
 9 
10 func (server * EchoServer) Handle(request string) string {
11     return "ECHO:" + request
12 }
13 
14 func (server * EchoServer) Name() string {
15     return "EchoServer"
16 }
17 
18 func TestIpc (t * testing.T) {
19     server := NewIpcServer(&EchoServer{})
20 
21     client1 := NewIpcClient(server)
22     client2 := NewIpcClient(server)
23 
24     resq1 := client1.Call("From client1")
25     resq2 := client1.Call("From client2")
26 
27     if resp1 != "ECHO:From client1" || resp2 != "ECHO:From client2" {
28         t.Error("IpcClient.Call faild. resp1:", resp1, "resp2:", resp2)
29     }
30     client1.Close()
31     client2.Close()
32 }

 1 package ipc
 2 
 3 import (
 4     "encoding/json"
 5     "fmt"
 6 )
 7 
 8 type Request struct {
 9     Method string "method"
10     Params string "params"
11 }
12 
13 type Response struct {
14     Code string "code"
15     Body string "body"
16 }
17 
18 type Server interface {
19     Name() string
20     Handle(method, params string) *Response
21 }
22 
23 type IpcServer struct {
24     Server
25 }
26 
27 func NewIpcServer(server Server) * IpcServer {
28     return &IpcServer{server}
29 }
30 
31 func (server * IpcServer)Connect() chan string {
32     session := make(chan string, 0)
33 
34     go func(c chan string) {
35         for{
36             request := <-c
37             if request == "CLOSE" {
38                 break
39             }
40             var req Request
41             err := json.Unmarshal([]byte(request), &req)
42             if err != nil {
43                 fmt.Println("Invalid request format:", request)
44             }
45             resp := server.Handle(req.Method, req.Params)
46 
47             b, err := json.Marshal(resp)
48             c <- string(b)
49         }
50         fmt.Println("Session closed.")
51     }(session)
52 
53     fmt.Println("A new session has been created successfully.")
54 
55     return session
56 }