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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
|
package rpc
import (
"net"
"net/rpc"
"sync/atomic"
"github.com/spiral/endure"
"github.com/spiral/errors"
"github.com/spiral/goridge/v2"
"github.com/spiral/roadrunner/v2/interfaces/log"
rpc_ "github.com/spiral/roadrunner/v2/interfaces/rpc"
"github.com/spiral/roadrunner/v2/plugins/config"
)
// ServiceName contains default service name.
const ServiceName = "RPC"
type pluggable struct {
service rpc_.RPCer
name string
}
// Plugin is RPC service.
type Plugin struct {
cfg Config
log log.Logger
rpc *rpc.Server
services []pluggable
listener net.Listener
closed *uint32
}
// Init rpc service. Must return true if service is enabled.
func (s *Plugin) Init(cfg config.Configurer, log log.Logger) error {
const op = errors.Op("RPC Init")
if !cfg.Has(ServiceName) {
return errors.E(op, errors.Disabled)
}
err := cfg.UnmarshalKey(ServiceName, &s.cfg)
if err != nil {
return err
}
s.cfg.InitDefaults()
if s.cfg.Disabled {
return errors.E(op, errors.Disabled)
}
s.log = log
state := uint32(0)
s.closed = &state
atomic.StoreUint32(s.closed, 0)
return s.cfg.Valid()
}
// Serve serves the service.
func (s *Plugin) Serve() chan error {
const op = errors.Op("register service")
errCh := make(chan error, 1)
s.rpc = rpc.NewServer()
services := make([]string, 0, len(s.services))
// Attach all services
for i := 0; i < len(s.services); i++ {
err := s.Register(s.services[i].name, s.services[i].service.RPC())
if err != nil {
errCh <- errors.E(op, err)
return errCh
}
services = append(services, s.services[i].name)
}
var err error
s.listener, err = s.cfg.Listener()
if err != nil {
errCh <- err
return errCh
}
s.log.Debug("Started RPC service", "address", s.cfg.Listen, "services", services)
go func() {
for {
conn, err := s.listener.Accept()
if err != nil {
if atomic.LoadUint32(s.closed) == 1 {
// just log and continue, this is not a critical issue, we just called Stop
s.log.Error("listener accept error, connection closed", "error", err)
return
}
s.log.Error("listener accept error", "error", err)
errCh <- errors.E(errors.Op("listener accept"), errors.Serve, err)
return
}
go s.rpc.ServeCodec(goridge.NewCodec(conn))
}
}()
return errCh
}
// Stop stops the service.
func (s *Plugin) Stop() error {
// store closed state
atomic.StoreUint32(s.closed, 1)
err := s.listener.Close()
if err != nil {
return errors.E(errors.Op("stop RPC socket"), err)
}
return nil
}
// Name contains service name.
func (s *Plugin) Name() string {
return ServiceName
}
// Depends declares services to collect for RPC.
func (s *Plugin) Collects() []interface{} {
return []interface{}{
s.RegisterPlugin,
}
}
// RegisterPlugin registers RPC service plugin.
func (s *Plugin) RegisterPlugin(name endure.Named, p rpc_.RPCer) {
s.services = append(s.services, pluggable{
service: p,
name: name.Name(),
})
}
// Register publishes in the server the set of methods of the
// receiver value that satisfy the following conditions:
// - exported method of exported type
// - two arguments, both of exported type
// - the second argument is a pointer
// - one return value, of type error
// It returns an error if the receiver is not an exported type or has
// no suitable methods. It also logs the error using package log.
func (s *Plugin) Register(name string, svc interface{}) error {
if s.rpc == nil {
return errors.E("RPC service is not configured")
}
return s.rpc.RegisterName(name, svc)
}
// Client creates new RPC client.
func (s *Plugin) Client() (*rpc.Client, error) {
conn, err := s.cfg.Dialer()
if err != nil {
return nil, err
}
return rpc.NewClientWithCodec(goridge.NewClientCodec(conn)), nil
}
|
