Support for server request and client response

[ScriptWorker]

We have a case when the server should make requests to the client. At this point this library do not have such functionality, while specification do not restrict regarding this.

Do you interested in merging such PR if we will implement it?

[mkozjak]

Hello! Can you just run both server and client instances on both sides? That would solve the case.

[ScriptWorker]

Hello! Unfortunately no, as the server can't connect to the client. Basically we can't guarantee, that the client won't be under the firewall protection or even to have an external ip address.

[mkozjak]

@ScriptWorker: Ok, I agree and I would gladly merge the feature if no current use cases break!

[mkozjak]

@ScriptWorker Any progress here, maybe?

[mkozjak]

This will be available in version 5.x. Currently in development.

[oxygen]

@ScriptWorker
https://www.npmjs.com/package/jsonrpc-bidirectional

[FMRb]

Any update on version 5.x? I would like the library to support this feature

[mkozjak]

@FMRb Unfortunately, no. Out of resources currently!

[davidmoshal]

you really ought to make it clear in the ReadMe that this is one-way, browser running procedures on a remote server only, because it's such a huge limitation of this library.

[mkozjak]

Will do, thanks!

…

On Wed, Apr 10, 2019, 15:48 davidmoshal ***@***.***> wrote: you really ought to make it clear in the ReadMe that this is one-way, browser running procedures on a remote server only, because it's such a huge limitation of this library. — You are receiving this because you commented. Reply to this email directly, view it on GitHub <#29 (comment)>, or mute the thread <https://github.com/notifications/unsubscribe-auth/ADV__KjQ6eu1aPPMLQAQzhG9b4sENY_vks5vfeuXgaJpZM4S6JYt> .

[mkozjak]

@ScriptWorker @davidmoshal @FMRb: This is now available in version 6.0.0-beta.0.

https://github.com/elpheria/rpc-websockets/blob/v6.x/API.md

[mkozjak]

@FMRb: btw, any initial feedback on this feature, maybe? :)

[mkozjak]

Due to positive feedback this will hit master soon. It’s currently released as 6.x in beta due to insufficient migration docs, but that should be available soon. Closing this one.

[huanshiwushuang]

My solution is that the client calls the server method, registers a function A, and then the server returns promise.
Then when calling A, make Promise resolve

example:

const res = {}

res.websocket = {
    makeUpServer(wsServer) {
        // client 注册方法
        wsServer.register('_calleeRegister', ({ methodName, namespace = '/', password = '' }) => {
            const registerPassword = password

            return new Promise((calleeResolve) => {
                wsServer.register(
                    methodName,
                    function (params) {
                        return new Promise((callerResolve, callerReject) => {
                            const { password } = params

                            // 密码校验不通过
                            if (registerPassword && registerPassword != password) {
                                return callerReject({
                                    state: 'fail',
                                    code: 'le3t8gjp',
                                    msg: `call password error`
                                })
                            }

                            // 删除密码
                            delete params.password

                            // 本次调用 id
                            const _callerCall = `${Date.now().toString(36)}-${Math.random()}`

                            // 转发 调用数据 给注册方
                            calleeResolve({
                                _callerCall,
                                params
                            })

                            // 缓存本次
                            _calleeReturn.value[_callerCall] = {
                                ms: Date.now(),
                                // 转发 返回数据 给调用方
                                callerResolve
                            }
                        })
                    },
                    namespace
                )
            })
        })
        // client 注册方法的返回
        const _calleeReturnCache = {
            // 清理超时的 callerResolve
            timeout: 1000 * 10,
            // 多久清理一次
            detectInterval: 1000 * 20,
            // 超时的 callerResolve
            value: {
                // _callerCall: {
                //     callerResolve: function () {},
                //     ms: Date.now(),
                // }
            }
        }
        // 定时检测超时的 _calleeReturnCache
        setInterval(() => {
            Object.keys(_calleeReturnCache.value).forEach((v) => {
                if (Date.now() - _calleeReturnCache.value[v].ms >= _calleeReturnCache.timeout) {
                    delete _calleeReturnCache.value[v]
                }
            })
        }, _calleeReturnCache.detectInterval)

        wsServer.register('_calleeReturn', ({ _callerCall, returnValue }) => {
            if (!_calleeReturnCache.value[_callerCall]) {
                return {
                    state: 'fail',
                    code: 'le3wr8e1',
                    msg: `not found _calleeReturnCache by _callerCall ${_callerCall}`
                }
            }
            _calleeReturnCache.value[_callerCall].callerResolve(returnValue)
            delete _calleeReturnCache.value[_callerCall]
            return 1
        })
    },
    makeUpClient(wsClient) {
        Object.assign(wsClient, {
            async register(methodName, handler, password = '', namespace = '/') {
                // 注册函数
                const start = async () => {
                    // 通知 Server 注册一个方法
                    const res = await wsClient.call(`_calleeRegister`, {
                        methodName,
                        namespace,
                        password
                    })
                    const { _callerCall, params } = res
                    let returnValue = handler(params)

                    if (/promise/i.test(returnValue.toString())) {
                        returnValue = await returnValue
                    }

                    wsClient.notify('_calleeReturn', {
                        _callerCall,
                        returnValue: returnValue || {}
                    })
                }
                await start()

                while (true) {
                    await start()
                }
            }
        })
    }
}

module.exports = res