func (client *inprocessClient) IsClosing() bool {
	return false
}
IsClosing always returns false.
package client
import (
	"context"
	"errors"
	"fmt"
	"reflect"
	"sync"
	"github.com/kudoochui/kudos/rpcx/log"
	"github.com/kudoochui/kudos/rpcx/protocol"
	"github.com/kudoochui/kudos/rpcx/share"
)
var InprocessClient = &inprocessClient{
	services: make(map[string]interface{}),
	methods:  make(map[string]*reflect.Value),
}
type inprocessClient struct {
	services map[string]interface{}
	sync.RWMutex
	methods map[string]*reflect.Value
	mmu     sync.RWMutex
	ServerMessageChan chan<- *protocol.Message
}
func (client *inprocessClient) Connect(network, address string) error {
	return nil
}
func (client *inprocessClient) RegisterServerMessageChan(ch chan<- *protocol.Message) {
	client.ServerMessageChan = ch
}
func (client *inprocessClient) UnregisterServerMessageChan() {
	client.ServerMessageChan = nil
}
func (client *inprocessClient) Go(ctx context.Context, servicePath, serviceMethod string, args interface{}, reply interface{}, done chan *Call) *Call {
	call := new(Call)
	call.ServicePath = servicePath
	call.ServiceMethod = serviceMethod
	meta := ctx.Value(share.ReqMetaDataKey)
	if meta != nil {  
		call.Metadata = meta.(map[string]string)
	}
	call.Args = args
	call.Reply = reply
	if done == nil {
		done = make(chan *Call, 10)  
	} else {
		if cap(done) == 0 {
			log.Panic("rpc: done channel is unbuffered")
		}
	}
	call.Done = done
	err := client.Call(ctx, servicePath, serviceMethod, args, reply)
	if err != nil {
		call.Error = ServiceError(err.Error())
	}
	call.done()
	return call
}
func (client *inprocessClient) Call(ctx context.Context, servicePath, serviceMethod string, args interface{}, reply interface{}) (err error) {
	defer func() {
		if e := recover(); e != nil {
			var ok bool
			if err, ok = e.(error); ok {
				err = fmt.Errorf("failed to call %s.%s because of %v", servicePath, serviceMethod, err)
			}
		}
	}()
	client.RLock()
	service := client.services[servicePath]
	client.RUnlock()
	if service == nil {
		return fmt.Errorf("service %s not found", servicePath)
	}
	key := servicePath + "." + serviceMethod
	client.mmu.RLock()
	var mv = &reflect.Value{}
	mv = client.methods[key]
	client.mmu.RUnlock()
	if mv == nil {
		client.mmu.Lock()
		mv = client.methods[key]
		if mv == nil {
			v := reflect.ValueOf(service)
			t := v.MethodByName(serviceMethod)
			if t == (reflect.Value{}) {
				client.mmu.Unlock()
				return fmt.Errorf("method %s.%s not found", servicePath, serviceMethod)
			}
			mv = &t
		}
		client.mmu.Unlock()
	}
	argv := reflect.ValueOf(args)
	replyv := reflect.ValueOf(reply)
	err = nil
	returnValues := mv.Call([]reflect.Value{reflect.ValueOf(ctx), argv, replyv})
	errInter := returnValues[0].Interface()
	if errInter != nil {
		err = errInter.(error)
	}
	return err
}
func (client *inprocessClient) SendRaw(ctx context.Context, r *protocol.Message) (map[string]string, []byte, error) {
	return nil, nil, errors.New("SendRaw method is not supported by inprocessClient")
}
func (client *inprocessClient) Close() error {
	return nil
}