gosrv/server.go at master · Cyberpull/gosrv · GitHub

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
package gosrv

import (
	"net"
	"sync"

	"cyberpull.com/gotk/v2/log"
)

type BootHandler func() (err error)
type ReadyHandler func() (err error)
type ClientBootHandler func(client NetIO) (err error)
type ClientReadyHandler func(client ClientUpdater) (err error)
type RequestHandlerSubscriber func(collection RequestHandlerCollection)

// =====================

type Server interface {
	Listen(errChan ...chan error)
	OnBoot(handlers ...BootHandler)
	OnReady(handlers ...ReadyHandler)
	OnClientBoot(handlers ...ClientBootHandler)
	OnClientReady(handlers ...ClientReadyHandler)
	RequestHandlers(subscribers ...RequestHandlerSubscriber)
	Stop() error
}

// =====================

type pServer struct {
	mutex       sync.Mutex
	listener    net.Listener
	opts        ServerOptions
	instances   map[string]*serverClientInstance
	collection  *pRequestHandlerCollection
	boot        []BootHandler
	ready       []ReadyHandler
	clientBoot  []ClientBootHandler
	clientReady []ClientReadyHandler
}

func (p *pServer) Listen(errChan ...chan error) {
	srvInfo := p.opts.getInfo()

	var err error

	defer p.Stop()

	if err = validator.Validate(p.opts); err != nil {
		sendOne(errChan, err)
		return
	}

	if err := p.execBoot(); err != nil {
		sendOne(errChan, err)
		return
	}

	if p.listener, err = listen(p.opts); err != nil {
		sendOne(errChan, err)
		return
	}

	log.Infofln("%s listening on %s...", srvInfo.Name, address(p.opts))

	if err := p.execReady(); err != nil {
		sendOne(errChan, err)
		return
	}

	sendOne(errChan, nil)

	for {
		var conn net.Conn

		if conn, err = p.listener.Accept(); err != nil {
			break
		}

		go p.handleIncomingConnection(conn)
	}
}

func (p *pServer) OnBoot(handlers ...BootHandler) {
	p.boot = append(p.boot, handlers...)
}

func (p *pServer) OnReady(handlers ...ReadyHandler) {
	p.ready = append(p.ready, handlers...)
}

func (p *pServer) RequestHandlers(subscribers ...RequestHandlerSubscriber) {
	for _, subscriber := range subscribers {
		subscriber(p.collection)
	}
}

func (p *pServer) OnClientBoot(handlers ...ClientBootHandler) {
	p.clientBoot = append(p.clientBoot, handlers...)
}

func (p *pServer) OnClientReady(handlers ...ClientReadyHandler) {
	p.clientReady = append(p.clientReady, handlers...)
}

func (p *pServer) Stop() error {
	if p.listener != nil {
		return p.listener.Close()
	}

	return nil
}

// =====================

func NewServer(opts ServerOptions) Server {
	value := &pServer{
		opts:        opts,
		instances:   make(map[string]*serverClientInstance),
		boot:        make([]BootHandler, 0),
		ready:       make([]ReadyHandler, 0),
		collection:  newRequestHandlerCollection(),
		clientBoot:  make([]ClientBootHandler, 0),
		clientReady: make([]ClientReadyHandler, 0),
	}

	return value
}