commons/rpc-go
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

ing

Browse Source
This commit is contained in:
crusader 2018-04-10 18:02:35 +09:00
parent 280cda6238
commit 9b0d093216
4 changed files with 15 additions and 243 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
protocol/json/client_notification.go
View File

@ -31,7 +31,7 @@ func (cnc *ClientNotificationCodec) ReadParams(args []interface{}) error {
if nil != cnc.noti.Params {
// Note: if scr.request.Params is nil it's not an error, it's an optional member.
// JSON params structured object. Unmarshal to the args object.
if err := cuej.SetValueWithJSONStringArray(*cnc.noti.Params, args); nil != err {
if err := cuej.SetValueWithJSONStringArrayBytes(*cnc.noti.Params, args); nil != err {
return err
}
return nil

2
protocol/json/server_request.go
View File

@ -92,7 +92,7 @@ func (src *ServerRequestCodec) ReadParams(args []interface{}) error {
if src.err == nil && src.req.Params != nil {
// Note: if scr.request.Params is nil it's not an error, it's an optional member.
// JSON params structured object. Unmarshal to the args object.
if err := cuej.SetValueWithJSONStringArray(*src.req.Params, args); nil != err {
if err := cuej.SetValueWithJSONStringArrayBytes(*src.req.Params, args); nil != err {
src.err = &protocol.Error{
Code: protocol.E_BAD_PARAMS,
Message: err.Error(),

25
registry/rpc_registry.go → registry/rpc-registry.go
View File

@ -4,12 +4,13 @@ import (
"reflect"
"git.loafle.net/commons/rpc-go/protocol"
cus "git.loafle.net/commons/util-go/service"
)
// NewRPCRegistry returns a new RPC registry.
func NewRPCRegistry() RPCRegistry {
return &rpcRegistry{
services: new(serviceMap),
serviceRegistry: new(cus.ServiceRegistry),
}
}
@ -23,7 +24,7 @@ type RPCRegistry interface {
// RPCRegistry serves registered RPC services using registered codecs.
type rpcRegistry struct {
services *serviceMap
serviceRegistry *cus.ServiceRegistry
}
// RegisterService adds a new service to the server.
@ -43,7 +44,7 @@ type rpcRegistry struct {
//
// All other methods are ignored.
func (rr *rpcRegistry) RegisterService(receiver interface{}, name string) error {
return rr.services.register(receiver, name)
return rr.serviceRegistry.Register(receiver, name)
}
func (rr *rpcRegistry) RegisterServices(receivers ...interface{}) error {
@ -52,7 +53,7 @@ func (rr *rpcRegistry) RegisterServices(receivers ...interface{}) error {
}
for _, receiver := range receivers {
if err := rr.services.register(receiver, ""); nil != err {
if err := rr.serviceRegistry.Register(receiver, ""); nil != err {
return err
}
}
@ -65,7 +66,7 @@ func (rr *rpcRegistry) RegisterServiceMap(keysAndValues map[string]interface{})
}
for name, receiver := range keysAndValues {
if err := rr.services.register(receiver, name); nil != err {
if err := rr.serviceRegistry.Register(receiver, name); nil != err {
return err
}
}
@ -73,14 +74,14 @@ func (rr *rpcRegistry) RegisterServiceMap(keysAndValues map[string]interface{})
}
func (rr *rpcRegistry) GetService(name string) interface{} {
return rr.services.getService(name)
return rr.serviceRegistry.GetService(name)
}
// HasMethod returns true if the given method is registered.
//
// The method uses a dotted notation as in "Service.Method".
func (rr *rpcRegistry) HasMethod(method string) bool {
if _, _, err := rr.services.get(method); err == nil {
if _, _, err := rr.serviceRegistry.Get(method); err == nil {
return true
}
return false
@ -92,14 +93,14 @@ func (rr *rpcRegistry) HasMethod(method string) bool {
// XML. A codec is chosen based on the "Content-Type" header from the request,
// excluding the charset definition.
func (rr *rpcRegistry) Invoke(codec protocol.RegistryCodec, leadingParams ...interface{}) (result interface{}, err error) {
serviceSpec, methodSpec, errGet := rr.services.get(codec.Method())
serviceSpec, methodSpec, errGet := rr.serviceRegistry.Get(codec.Method())
if nil != errGet {
return nil, errGet
}
// Decode the args.
var in []reflect.Value
pValues, pInstances := methodSpec.getParamValues()
pValues, pInstances := methodSpec.ParamValues()
var lParamLen int
if nil != leadingParams {
lParamLen = len(leadingParams)
@ -135,12 +136,12 @@ func (rr *rpcRegistry) Invoke(codec protocol.RegistryCodec, leadingParams ...int
} else {
in = make([]reflect.Value, 1)
}
in[0] = serviceSpec.rcvrV
in[0] = serviceSpec.ReceiverValue()
// Call the service method.
returnValues := methodSpec.method.Func.Call(in)
returnValues := methodSpec.Call(in)
if nil != methodSpec.returnType {
if nil != methodSpec.ReturnType() {
result = returnValues[0].Interface()
if nil != returnValues[1].Interface() {
err = returnValues[1].Interface().(error)

229
registry/service_map.go
View File

@ -1,229 +0,0 @@
package registry
import (
"fmt"
"reflect"
"strings"
"sync"
"unicode"
"unicode/utf8"
)
var (
// Precompute the reflect.Type of error and http.Request
typeOfError = reflect.TypeOf((*error)(nil)).Elem()
)
// ----------------------------------------------------------------------------
// service
// ----------------------------------------------------------------------------
type service struct {
name string // name of service
rcvrV reflect.Value // receiver of methods for the service
rcvrT reflect.Type // type of the receiver
methods map[string]*serviceMethod // registered methods
}
type serviceMethod struct {
method reflect.Method // receiver method
paramTypes []reflect.Type // type of the request argument
returnType reflect.Type // type of the response argument
}
func (sm *serviceMethod) getParamValues() (values []reflect.Value, instances []interface{}) {
if nil == sm.paramTypes || 0 == len(sm.paramTypes) {
return nil, nil
}
pCount := len(sm.paramTypes)
values = make([]reflect.Value, pCount)
instances = make([]interface{}, pCount)
for indexI := 0; indexI < pCount; indexI++ {
values[indexI] = getValue(sm.paramTypes[indexI])
instances[indexI] = values[indexI].Interface()
}
return
}
func getValue(t reflect.Type) reflect.Value {
rt := t
if rt.Kind() == reflect.Ptr {
rt = rt.Elem()
}
// rv := reflect.New(rt)
// if rt.Kind() != reflect.Struct {
// rv = reflect.Indirect(rv)
// }
// var rv reflect.Value
// switch rt.Kind() {
// case reflect.Slice:
// rv = reflect.New(reflect.SliceOf(rt.Elem()))
// default:
// rv = reflect.New(rt)
// }
return reflect.New(rt)
}
// ----------------------------------------------------------------------------
// serviceMap
// ----------------------------------------------------------------------------
// serviceMap is a registry for services.
type serviceMap struct {
mutex sync.RWMutex
services map[string]*service
}
func (sm *serviceMap) getService(name string) interface{} {
sm.mutex.RLock()
defer sm.mutex.RUnlock()
if sm.services == nil {
return nil
}
return sm.services[name]
}
// register adds a new service using reflection to extract its methods.
func (sm *serviceMap) register(rcvr interface{}, name string) error {
// Setup service.
s := &service{
name: name,
rcvrV: reflect.ValueOf(rcvr),
rcvrT: reflect.TypeOf(rcvr),
methods: make(map[string]*serviceMethod),
}
if name == "" {
s.name = reflect.Indirect(s.rcvrV).Type().Name()
if !isExported(s.name) {
return fmt.Errorf("rpc: type %q is not exported", s.name)
}
}
if s.name == "" {
return fmt.Errorf("rpc: no service name for type %q",
s.rcvrT.String())
}
var err error
// Setup methods.
Loop:
for i := 0; i < s.rcvrT.NumMethod(); i++ {
m := s.rcvrT.Method(i)
mt := m.Type
// Method must be exported.
if m.PkgPath != "" {
continue
}
var paramTypes []reflect.Type
var returnType reflect.Type
pCount := mt.NumIn() - 1
if 0 < pCount {
paramTypes = make([]reflect.Type, pCount)
for indexI := 0; indexI < pCount; indexI++ {
pt := mt.In(indexI + 1)
if err = validateType(mt.In(indexI + 1)); nil != err {
return err
}
paramTypes[indexI] = pt
}
}
switch mt.NumOut() {
case 1:
if t := mt.Out(0); t != typeOfError {
continue Loop
}
case 2:
if t := mt.Out(0); !isExportedOrBuiltin(t) {
continue Loop
}
if t := mt.Out(1); t != typeOfError {
continue Loop
}
rt := mt.Out(0)
if err = validateType(rt); nil != err {
return err
}
returnType = rt
default:
continue
}
s.methods[m.Name] = &serviceMethod{
method: m,
paramTypes: paramTypes,
returnType: returnType,
}
}
if len(s.methods) == 0 {
return fmt.Errorf("rpc: %q has no exported methods of suitable type", s.name)
}
// Add to the map.
sm.mutex.Lock()
defer sm.mutex.Unlock()
if sm.services == nil {
sm.services = make(map[string]*service)
} else if _, ok := sm.services[s.name]; ok {
return fmt.Errorf("rpc: service already defined: %q", s.name)
}
sm.services[s.name] = s
return nil
}
func validateType(t reflect.Type) error {
if t.Kind() == reflect.Struct {
return fmt.Errorf("Type is Struct. Pass by reference, i.e. *%s", t)
}
return nil
}
// get returns a registered service given a method name.
//
// The method name uses a dotted notation as in "Service.Method".
func (sm *serviceMap) get(method string) (*service, *serviceMethod, error) {
parts := strings.Split(method, ".")
if len(parts) != 2 {
err := fmt.Errorf("rpc: service/method request ill-formed: %q", method)
return nil, nil, err
}
sm.mutex.Lock()
service := sm.services[parts[0]]
sm.mutex.Unlock()
if service == nil {
err := fmt.Errorf("rpc: can't find service %q", method)
return nil, nil, err
}
serviceMethod := service.methods[parts[1]]
if serviceMethod == nil {
err := fmt.Errorf("rpc: can't find method %q", method)
return nil, nil, err
}
return service, serviceMethod, nil
}
// isExported returns true of a string is an exported (upper case) name.
func isExported(name string) bool {
rune, _ := utf8.DecodeRuneInString(name)
return unicode.IsUpper(rune)
}
// isExportedOrBuiltin returns true if a type is exported or a builtin.
func isExportedOrBuiltin(t reflect.Type) bool {
for t.Kind() == reflect.Ptr {
t = t.Elem()
}
// PkgPath will be non-empty even for an exported type,
// so we need to check the type name as well.
return isExported(t.Name()) || t.PkgPath() == ""
}