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
|
package rpc
import (
"net"
"net/rpc"
"sync/atomic"
endure "github.com/spiral/endure/pkg/container"
"github.com/spiral/errors"
goridgeRpc "github.com/spiral/goridge/v3/pkg/rpc"
"github.com/spiral/roadrunner/v2/plugins/config"
"github.com/spiral/roadrunner/v2/plugins/logger"
)
// PluginName contains default plugin name.
const PluginName = "RPC"
type pluggable struct {
service RPCer
name string
}
// Plugin is RPC service.
type Plugin struct {
cfg Config
log logger.Logger
rpc *rpc.Server
// set of the plugins, which are implement RPCer interface and can be plugged into the RR via RPC
plugins []pluggable
listener net.Listener
closed *uint32
}
// Init rpc service. Must return true if service is enabled.
func (s *Plugin) Init(cfg config.Configurer, log logger.Logger) error {
const op = errors.Op("rpc_plugin_init")
if !cfg.Has(PluginName) {
return errors.E(op, errors.Disabled)
}
err := cfg.UnmarshalKey(PluginName, &s.cfg)
if err != nil {
return errors.E(op, errors.Disabled, err)
}
s.cfg.InitDefaults()
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("rpc_plugin_serve")
errCh := make(chan error, 1)
s.rpc = rpc.NewServer()
services := make([]string, 0, len(s.plugins))
// Attach all services
for i := 0; i < len(s.plugins); i++ {
err := s.Register(s.plugins[i].name, s.plugins[i].service.RPC())
if err != nil {
errCh <- errors.E(op, err)
return errCh
}
services = append(services, s.plugins[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 continue, this is not a critical issue, we just called Stop
return
}
s.log.Error("listener accept error", "error", err)
errCh <- errors.E(errors.Op("listener accept"), errors.Serve, err)
return
}
go s.rpc.ServeCodec(goridgeRpc.NewCodec(conn))
}
}()
return errCh
}
// Stop stops the service.
func (s *Plugin) Stop() error {
const op = errors.Op("rpc_plugin_stop")
// store closed state
atomic.StoreUint32(s.closed, 1)
err := s.listener.Close()
if err != nil {
return errors.E(op, err)
}
return nil
}
// Name contains service name.
func (s *Plugin) Name() string {
return PluginName
}
// 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 RPCer) {
s.plugins = append(s.plugins, 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(goridgeRpc.NewClientCodec(conn)), nil
}
|
