XSocket 2.1.0__tar.gz

xsocket-2.1.0/LICENSE

@@ -0,0 +1,24 @@
+# License
+
+[The MIT License (MIT)](http://opensource.org/licenses/MIT)
+
+Copyright (c) 2009-2013 Jeff Mott  
+Copyright (c) 2013-2016 Evan Vosberg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

xsocket-2.1.0/PKG-INFO

@@ -0,0 +1,122 @@
+Metadata-Version: 2.4
+Name: xsocket
+Version: 2.1.0
+Summary: WebSocket client and server for Python (asyncio), compatible with xSocket for Node.js and the browser
+Author: pr!de
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/pride-oO/xsocket
+Keywords: socket,ws,wss,websocket,message,client,server,asyncio
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: websockets>=13
+Dynamic: license-file
+
+rfr# xSocket for Python
+
+WebSocket client and server for Python (asyncio). Same protocol as [xSocket](https://github.com/pride-oO/xsocket) for Node.js and the browser: a Python server works with JS clients, a Python client works with a Node.js server.
+
+- Request-response with TTL (`sendReady`), clock synchronization with the server
+- Automatic reconnect and session recovery within `socketObjectTimeout`
+- Auth hook on the server (`use('auth')`)
+- `ws://` or `wss://` depending on certificate, optional `perMessageDeflate` compression
+- Binary messages: `bytes`, `bytearray` or `memoryview` as data, received as `bytes`
+- Python 3.9+, depends on [websockets](https://pypi.org/project/websockets/)
+
+```
+pip install xsocket
+```
+
+The API mirrors the JS version. Methods that return a `Promise` in JS (`send`, `sendReady`, `response`) return an awaitable task here: the message is sent even without `await`. Event handlers can be regular functions or coroutines and receive the same arguments as in JS. `Client` and `Server` must be created inside a running event loop.
+
+## Server:
+```python
+import asyncio
+import xsocket
+
+async def main():
+    xServer = xsocket.Server({
+        'port' : 8752, # (Not necessary) Port listen (Default: 443 with certificate, 80 without)
+        'socketObjectTimeout' : 30000, # (Not necessary) Allows the user to reconnect within 30 seconds (Default: 0)
+        'perMessageDeflate' : True, # (Not necessary) Compress messages (Default: False)
+        'https' : { # (Not necessary) Without certificate server uses ws:// instead of wss://
+            'cert' : '<path>/cert.pem',
+            'key' : '<path>/private.key'
+        }
+    })
+
+    # (Not necessary) Auth, by default all connections are allowed. Can be async
+    def auth(xSocketObject, success, failed):
+        if xSocketObject.getQueryVal('name'):
+            return success()
+        failed('Access denied')
+
+    xServer.use('auth', auth)
+
+    def onConnect(xSocketObject):
+        print('Connect event:', xSocketObject.getID(), xSocketObject.getIP(), xSocketObject.getOrigin(), xSocketObject.getQuery(), xSocketObject.getReqHeaders())
+
+        async def onData(xSocketData):
+            print('Data event', xSocketData.getID(), xSocketData.getType(), xSocketData.getData())
+            await asyncio.sleep(1)
+            try:
+                await xSocketData.response({'welcome' : 'Hello ' + xSocketObject.getQueryVal('name')})
+                # OR
+                # await xSocketData.response({}, 'Permision denied')
+            except xsocket.XSocketError as e:
+                print('Response send failed', xSocketData.getID(), e)
+
+        xSocketObject.on('data', onData)
+        xSocketObject.on('disconnect', lambda xSocketObject, msg: print('Disconnect event:', xSocketObject.getID(), msg))
+        xSocketObject.on('reconnect', lambda xSocketObject: print('Reconnect event:', xSocketObject.getID()))
+        xSocketObject.on('destroy', lambda xSocketObject, msg: print('Destroy event:', xSocketObject.getID(), msg))
+
+    xServer.on('connect', onConnect)
+    xServer.on('listen', lambda: print('Listen event', xServer.getPort()))
+
+    await xServer.listen()
+    await asyncio.Future()
+
+asyncio.run(main())
+```
+
+## Client:
+```python
+import asyncio
+import xsocket
+
+async def main():
+    xClient = xsocket.Client(['wss://server_domain.com:8752'], {'name' : 'Bob'}) # ws:// if server without certificate
+    # Self-signed certificate: xsocket.Client(url, query, {'ssl' : ssl.SSLContext})
+
+    xClient.on('reconnect', lambda xSocketObject: print('reconnect event', xSocketObject.getID()))
+    xClient.on('disconnect', lambda xSocketObject, msg: print('disconnect', xSocketObject.getID(), msg))
+    xClient.on('destroy', lambda xSocketObject, msg: print('destroy', xSocketObject.getID(), msg))
+
+    # Messages from server
+    xClient.on('data', lambda xSocketData: xSocketData.response({'ok' : True}))
+
+    xSocketObject = await xClient.getSocketObjectReady()
+    print('connect event:', xSocketObject.getID())
+
+    try:
+        xSocketData = await xClient.sendReady(
+            'helloServer', # Name message
+            {'message' : 'Hello server'}, # Data message
+            2000 # TTL ready response (Default: 3s)
+        )
+        print('Server responsed #' + xSocketData.getID(), xSocketData.getType(), xSocketData.getResData())
+    except xsocket.XSocketError as e:
+        print('Server responsed error', e)
+
+    # Binary message, response can be binary too
+    # xSocketData = await xClient.sendReady('file', b'\x01\x02\x03')
+
+    # Without waiting for response
+    # await xClient.send('log', {'message' : 'Hello'}, 0)
+
+    # Close connection and destroy session on server
+    await xClient.close()
+
+asyncio.run(main())
+```

xsocket-2.1.0/README.md

@@ -0,0 +1,108 @@
+rfr# xSocket for Python
+
+WebSocket client and server for Python (asyncio). Same protocol as [xSocket](https://github.com/pride-oO/xsocket) for Node.js and the browser: a Python server works with JS clients, a Python client works with a Node.js server.
+
+- Request-response with TTL (`sendReady`), clock synchronization with the server
+- Automatic reconnect and session recovery within `socketObjectTimeout`
+- Auth hook on the server (`use('auth')`)
+- `ws://` or `wss://` depending on certificate, optional `perMessageDeflate` compression
+- Binary messages: `bytes`, `bytearray` or `memoryview` as data, received as `bytes`
+- Python 3.9+, depends on [websockets](https://pypi.org/project/websockets/)
+
+```
+pip install xsocket
+```
+
+The API mirrors the JS version. Methods that return a `Promise` in JS (`send`, `sendReady`, `response`) return an awaitable task here: the message is sent even without `await`. Event handlers can be regular functions or coroutines and receive the same arguments as in JS. `Client` and `Server` must be created inside a running event loop.
+
+## Server:
+```python
+import asyncio
+import xsocket
+
+async def main():
+    xServer = xsocket.Server({
+        'port' : 8752, # (Not necessary) Port listen (Default: 443 with certificate, 80 without)
+        'socketObjectTimeout' : 30000, # (Not necessary) Allows the user to reconnect within 30 seconds (Default: 0)
+        'perMessageDeflate' : True, # (Not necessary) Compress messages (Default: False)
+        'https' : { # (Not necessary) Without certificate server uses ws:// instead of wss://
+            'cert' : '<path>/cert.pem',
+            'key' : '<path>/private.key'
+        }
+    })
+
+    # (Not necessary) Auth, by default all connections are allowed. Can be async
+    def auth(xSocketObject, success, failed):
+        if xSocketObject.getQueryVal('name'):
+            return success()
+        failed('Access denied')
+
+    xServer.use('auth', auth)
+
+    def onConnect(xSocketObject):
+        print('Connect event:', xSocketObject.getID(), xSocketObject.getIP(), xSocketObject.getOrigin(), xSocketObject.getQuery(), xSocketObject.getReqHeaders())
+
+        async def onData(xSocketData):
+            print('Data event', xSocketData.getID(), xSocketData.getType(), xSocketData.getData())
+            await asyncio.sleep(1)
+            try:
+                await xSocketData.response({'welcome' : 'Hello ' + xSocketObject.getQueryVal('name')})
+                # OR
+                # await xSocketData.response({}, 'Permision denied')
+            except xsocket.XSocketError as e:
+                print('Response send failed', xSocketData.getID(), e)
+
+        xSocketObject.on('data', onData)
+        xSocketObject.on('disconnect', lambda xSocketObject, msg: print('Disconnect event:', xSocketObject.getID(), msg))
+        xSocketObject.on('reconnect', lambda xSocketObject: print('Reconnect event:', xSocketObject.getID()))
+        xSocketObject.on('destroy', lambda xSocketObject, msg: print('Destroy event:', xSocketObject.getID(), msg))
+
+    xServer.on('connect', onConnect)
+    xServer.on('listen', lambda: print('Listen event', xServer.getPort()))
+
+    await xServer.listen()
+    await asyncio.Future()
+
+asyncio.run(main())
+```
+
+## Client:
+```python
+import asyncio
+import xsocket
+
+async def main():
+    xClient = xsocket.Client(['wss://server_domain.com:8752'], {'name' : 'Bob'}) # ws:// if server without certificate
+    # Self-signed certificate: xsocket.Client(url, query, {'ssl' : ssl.SSLContext})
+
+    xClient.on('reconnect', lambda xSocketObject: print('reconnect event', xSocketObject.getID()))
+    xClient.on('disconnect', lambda xSocketObject, msg: print('disconnect', xSocketObject.getID(), msg))
+    xClient.on('destroy', lambda xSocketObject, msg: print('destroy', xSocketObject.getID(), msg))
+
+    # Messages from server
+    xClient.on('data', lambda xSocketData: xSocketData.response({'ok' : True}))
+
+    xSocketObject = await xClient.getSocketObjectReady()
+    print('connect event:', xSocketObject.getID())
+
+    try:
+        xSocketData = await xClient.sendReady(
+            'helloServer', # Name message
+            {'message' : 'Hello server'}, # Data message
+            2000 # TTL ready response (Default: 3s)
+        )
+        print('Server responsed #' + xSocketData.getID(), xSocketData.getType(), xSocketData.getResData())
+    except xsocket.XSocketError as e:
+        print('Server responsed error', e)
+
+    # Binary message, response can be binary too
+    # xSocketData = await xClient.sendReady('file', b'\x01\x02\x03')
+
+    # Without waiting for response
+    # await xClient.send('log', {'message' : 'Hello'}, 0)
+
+    # Close connection and destroy session on server
+    await xClient.close()
+
+asyncio.run(main())
+```

xsocket-2.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "xsocket"
+dynamic = ["version"]
+description = "WebSocket client and server for Python (asyncio), compatible with xSocket for Node.js and the browser"
+readme = "README.md"
+license = "MIT"
+authors = [{ name = "pr!de" }]
+requires-python = ">=3.9"
+dependencies = ["websockets>=13"]
+keywords = ["socket", "ws", "wss", "websocket", "message", "client", "server", "asyncio"]
+
+[project.urls]
+Homepage = "https://github.com/pride-oO/xsocket"
+
+[tool.setuptools]
+packages = ["xsocket"]
+
+[tool.setuptools.dynamic]
+version = { attr = "xsocket.helpers.VERSION" }

xsocket-2.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

xsocket-2.1.0/xsocket/__init__.py

@@ -0,0 +1,7 @@
+from .helpers import VERSION, EventEmitter, XSocketError
+from .data import Data
+from .socket_object import SocketObject
+from .client import Client
+from .server import Server
+
+__version__ = VERSION

xsocket-2.1.0/xsocket/client.py

@@ -0,0 +1,197 @@
+import asyncio
+from urllib.parse import quote, urlencode
+
+from websockets.asyncio.client import connect
+from websockets.exceptions import ConnectionClosed
+
+from . import helpers
+from .helpers import Connection, EventEmitter, XSocketError, logger
+from .socket_object import SocketObject
+
+
+class Client(EventEmitter):
+
+    def __init__(self, serverUrl, query=None, settings=None):
+        super().__init__()
+        self.setMaxListeners(0)
+
+        if isinstance(serverUrl, str):
+            self._urlList = [serverUrl]
+        elif isinstance(serverUrl, (list, tuple)):
+            self._urlList = list(serverUrl)
+        else:
+            self._urlList = []
+        if not self._urlList:
+            raise XSocketError('Invalid urlList')
+        self._query           = dict(query) if isinstance(query, dict) else {}
+        self._settings        = dict(settings) if isinstance(settings, dict) else {}
+        self._ws              = None
+        self._socketObject    = None
+        self._isVersionWarned = False
+        self._isClose         = False
+
+        self.on('connect', self.__onConnect)
+        self._runTask = helpers.promise(self.__run())
+
+    def getSettings(self):
+        return self._settings
+
+    def getSettingsVal(self, key, default=None):
+        return self.getSettings().get(key) or default
+
+    def getSocketObject(self):
+        return self._socketObject or False
+
+    async def getSocketObjectReady(self):
+        if self.getSocketObject():
+            return self.getSocketObject()
+        future = asyncio.get_running_loop().create_future()
+        self.once('connect', lambda socketObject: future.done() or future.set_result(socketObject))
+        return await future
+
+    def send(self, type, data=None, ttl=None):
+        return helpers.promise(self.__send(type, data, ttl))
+
+    async def __send(self, type, data, ttl):
+        socketObject = await self.getSocketObjectReady()
+        return await socketObject.send(type, data, ttl)
+
+    def sendReady(self, type, data=None, ttl=None):
+        return helpers.promise(self.__sendReady(type, data, ttl))
+
+    sendReadyResponse = sendReady
+
+    async def __sendReady(self, type, data, ttl):
+        socketObject = await self.getSocketObjectReady()
+        return await socketObject.sendReady(type, data, ttl)
+
+    def disconnect(self, msg=None):
+        socketObject = self.getSocketObject()
+        if not socketObject:
+            return False
+        return socketObject.disconnect(msg)
+
+    async def close(self, msg='end'):
+        self._isClose = True
+        if not self._ws or not self._ws.closeConnection(msg):
+            self._runTask.cancel()
+        await asyncio.gather(self._runTask, return_exceptions=True)
+        if self._socketObject:
+            self._socketObject.destroy(msg)
+
+    def __getUrl(self):
+        url = self._urlList[helpers.getRandInt(0, len(self._urlList) - 1)]
+        query = dict(self._query)
+        query['xV'] = helpers.VERSION
+        if self._socketObject and self._socketObject.getID() and self._socketObject.getSign():
+            query['xSOId']   = self._socketObject.getID()
+            query['xSOSign'] = self._socketObject.getSign()
+        return url + ('&' if '?' in url else '?') + urlencode({str(key): str(val) for key, val in query.items()}, quote_via=quote)
+
+    async def __run(self):
+        while not self._isClose:
+            try:
+                websocket = await connect(self.__getUrl(), ssl=self.getSettingsVal('ssl'), max_size=helpers.MAX_MESSAGE_SIZE)
+            except Exception as e:
+                self.emit('ws|error', str(e))
+                await asyncio.sleep(1)
+                continue
+            await self.__handleConnection(websocket)
+            if not self._isClose:
+                await asyncio.sleep(1)
+
+    async def __handleConnection(self, websocket):
+        ws = Connection(websocket)
+        self._ws = ws
+        if self._isClose:
+            ws.closeConnection('end')
+        self.emit('ws|connect', ws)
+        msgInc = 0
+
+        async def pongCheck():
+            nonlocal msgInc
+            while True:
+                await asyncio.sleep(21)
+                if not msgInc:
+                    ws.closeConnection('pingTimeout')
+                msgInc = 0
+
+        pongTask = helpers.promise(pongCheck())
+        try:
+            async for message in websocket:
+                msgInc += 1
+                if message == 'ping':
+                    ws.sendMessage('pong')
+                    continue
+                try:
+                    self.__onMessage(ws, message)
+                except Exception:
+                    logger.exception('Message handler error')
+        except ConnectionClosed:
+            pass
+        finally:
+            pongTask.cancel()
+            await websocket.wait_closed()
+            ws.stop()
+            self._ws = None
+            msg = websocket.close_reason or 'close'
+            self.emit('ws|disconnect', msg)
+            if self._socketObject:
+                self._socketObject.emit('ws|disconnect', msg)
+
+    def __onMessage(self, ws, message):
+        body = helpers.decodeMessage(message)
+        if not body:
+            return
+        if body[0] != helpers.MSG_SO_UPDATE:
+            if self._socketObject:
+                self._socketObject.emit('ws|message', body)
+            return
+        body = body + [None] * (6 - len(body))
+        if body[4] != helpers.VERSION and not self._isVersionWarned:
+            self._isVersionWarned = True
+            logger.warning('Version mismatch client %s, server %s', helpers.VERSION, body[4] or 'unknown')
+        ws.setTimeOffset(body[5] - helpers.getTime() if helpers.isNumber(body[5]) else 0)
+        ws.setQuery({
+            'xSOId'     : str(body[1]),
+            'xSOSign'   : str(body[2]),
+            'configure' : body[3] if isinstance(body[3], dict) else {}
+        })
+        if self._socketObject:
+            query = ws.getQuery()
+            if query['xSOId'] == self._socketObject.getID() and query['xSOSign'] == self._socketObject.getSign() and self._socketObject.update(ws):
+                return
+            self._socketObject.destroy('update')
+            self._socketObject = None
+        socketObject = self._socketObject = SocketObject()
+        socketObject.once('connect', lambda socketObject: self.emit('connect', socketObject))
+        socketObject.on('destroy', self.__onSocketObjectDestroy)
+        socketObject.on('disconnect', lambda socketObject, msg: self.emit('disconnect', socketObject, msg))
+        socketObject.on('reconnect', lambda socketObject: self.emit('reconnect', socketObject))
+        socketObject.on('data', lambda socketData: self.emit('data', socketData))
+        if not socketObject.update(ws):
+            ws.closeConnection('update')
+
+    def __onSocketObjectDestroy(self, socketObject, msg):
+        if self._socketObject is socketObject:
+            self._socketObject = None
+        self.emit('destroy', socketObject, msg)
+
+    def __onConnect(self, socketObject):
+        loop = asyncio.get_running_loop()
+        timerMap = {'destroy' : None}
+
+        def setDestroyTimeout(action, ttl=0):
+            if timerMap['destroy']:
+                timerMap['destroy'].cancel()
+                timerMap['destroy'] = None
+            if action:
+                timerMap['destroy'] = loop.call_later(max(ttl, 0) / 1000, socketObject.destroy, 'socketObjectTimeout')
+
+        def disconnectHandler(socketObject, msg):
+            configure = socketObject.getQueryVal('configure', {})
+            setDestroyTimeout(True, helpers.toInt(configure.get('socketObjectTimeout') if isinstance(configure, dict) else 0))
+
+        socketObject.on('reconnect', lambda socketObject: setDestroyTimeout(False))
+        socketObject.on('disconnect', disconnectHandler)
+        socketObject.once('destroy', lambda socketObject, msg: setDestroyTimeout(False))

xsocket-2.1.0/xsocket/data.py

@@ -0,0 +1,169 @@
+import asyncio
+
+from . import helpers
+from .helpers import EventEmitter, XSocketError
+
+
+class Data(EventEmitter):
+
+    STATUS_NEW      = 0
+    STATUS_SEND     = 1
+    STATUS_RESPONSE = 2
+    DEFAULT_TTL     = 3000
+
+    def __init__(self, isOutput, dataObject=None, socketObject=None):
+        super().__init__()
+        self.setMaxListeners(0)
+        dataObject = dataObject if isinstance(dataObject, dict) else {}
+
+        ID   = dataObject.get('ID')
+        type = dataObject.get('type')
+        data = dataObject.get('data')
+        ttl  = dataObject.get('ttl')
+        time = dataObject.get('time')
+
+        self._isOutput     = bool(isOutput)
+        self._socketObject = socketObject
+        self._ID           = ID if isinstance(ID, str) else ''
+        self._type         = type if isinstance(type, str) else ''
+        self._data         = data if helpers.isObject(data) else {}
+        self._ttl          = ttl if helpers.isInt(ttl) and ttl >= 0 else Data.DEFAULT_TTL
+        now                = socketObject.getTime() if socketObject else helpers.getTime()
+        self._time         = time if helpers.isNumber(time) and time > 0 else now
+        self._resData      = {}
+        self._error        = False
+        self._status       = Data.STATUS_NEW
+        self._destroy      = False
+        self._ttlTimeout   = asyncio.get_running_loop().call_later(
+            max(0, min(self._ttl, self._ttl - (now - self._time))) / 1000,
+            self.destroy, 'ttl', True
+        )
+
+    def getID(self):
+        return str(self._ID)
+
+    def getType(self):
+        return str(self._type)
+
+    def getTTL(self):
+        return self._ttl
+
+    def getTime(self):
+        return self._time
+
+    def getData(self):
+        return self._data
+
+    def getDataVal(self, key, default=None):
+        try:
+            return self.getData()[key] or default
+        except (KeyError, IndexError, TypeError):
+            return default
+
+    def getResData(self):
+        return self._resData
+
+    def getResDataVal(self, key, default=None):
+        try:
+            return self.getResData()[key] or default
+        except (KeyError, IndexError, TypeError):
+            return default
+
+    def getStatus(self):
+        return self._status
+
+    def getDestroy(self):
+        return self._destroy or False
+
+    def getSocketObject(self):
+        return self._socketObject
+
+    def getError(self):
+        return self._error or False
+
+    def isNew(self):
+        return self._status == Data.STATUS_NEW
+
+    def isSend(self):
+        return self._status == Data.STATUS_SEND
+
+    def isResponse(self):
+        return self._status == Data.STATUS_RESPONSE
+
+    def response(self, data=None, error=None):
+        return helpers.promise(self.__response(data, error))
+
+    async def __response(self, data, error):
+        if self._isOutput:
+            raise XSocketError('Output data')
+        if self._destroy or self.isResponse() or not self._ttl:
+            raise XSocketError('destroy')
+        self.setResData(data)
+        self.setError(error)
+        future = asyncio.get_running_loop().create_future()
+
+        def responseHandler(resData, error):
+            if not future.done():
+                future.set_result(self)
+
+        def destroyHandler(msg):
+            if not future.done():
+                future.set_exception(XSocketError(msg))
+
+        self.once('response', responseHandler)
+        self.once('destroy', destroyHandler)
+        try:
+            ws = await self._socketObject.getWsReady()
+            if ws.sendObject([
+                helpers.MSG_SD_UPDATE,
+                int(self._ID),
+                self.getResData(),
+                self.getError()
+            ]):
+                self.setStatus(Data.STATUS_RESPONSE)
+            else:
+                self.destroy('Send failed')
+        except Exception as e:
+            self.destroy(str(e) or 'Send failed')
+        return await future
+
+    def setStatus(self, status):
+        if (
+            status not in (Data.STATUS_SEND, Data.STATUS_RESPONSE) or
+            self._status == Data.STATUS_RESPONSE or
+            self._status == status
+        ):
+            return False
+        self._status = status
+        self.emit('setStatus', status)
+        if status == Data.STATUS_RESPONSE:
+            self.emit('response', self.getResData(), self.getError())
+            self.destroy('response')
+        return True
+
+    def setError(self, errorMsg):
+        if not isinstance(errorMsg, str):
+            return False
+        self._error = errorMsg
+        return True
+
+    def setResData(self, data):
+        if data is None:
+            data = {}
+        if not helpers.isObject(data):
+            return False
+        self._resData = data
+        return True
+
+    def destroy(self, msg=None, isSetError=False):
+        if self._destroy:
+            return False
+        self._destroy = msg if isinstance(msg, str) and msg else 'destroy'
+        self._ttlTimeout.cancel()
+        if isSetError and not self._error:
+            self.setError(self._destroy)
+        if self._status != Data.STATUS_RESPONSE:
+            self.setStatus(Data.STATUS_RESPONSE)
+        self.emit('destroy', self._destroy)
+        self.clearAllListeners()
+        return True