unitree_sdk2_python/unitree_sdk2py/rpc/server.py

122 lines
4.0 KiB
Python
Raw Normal View History

2024-04-26 21:26:50 +08:00
import time
from typing import Callable, Any
from ..idl.unitree_api.msg.dds_ import Request_ as Request
from ..idl.unitree_api.msg.dds_ import ResponseStatus_ as ResponseStatus
from ..idl.unitree_api.msg.dds_ import ResponseHeader_ as ResponseHeader
from ..idl.unitree_api.msg.dds_ import Response_ as Response
from .server_base import ServerBase
from .lease_server import LeaseServer
from .internal import *
"""
" class Server
"""
class Server(ServerBase):
def __init__(self, name: str):
self.__apiVersion = ""
self.__apiHandlerMapping = {}
self.__apiBinaryHandlerMapping = {}
self.__apiBinarySet = {}
self.__enableLease = False
self.__leaseServer = None
super().__init__(name)
def Init(self):
pass
def StartLease(self, term: float = 1.0):
self.__enableLease = True
self.__leaseServer = LeaseServer(self.GetName(), term)
self.__leaseServer.Init()
self.__leaseServer.Start(False)
def Start(self, enablePrioQueue: bool = False):
super()._SetServerRequestHandler(self.__ServerRequestHandler)
super()._Start(enablePrioQueue)
def GetApiVersion(self):
return self.__apiVersion
def _SetApiVersion(self, apiVersion: str):
self.__apiVersion = apiVersion
print("[Server] set api version:", self.__apiVersion)
def _RegistHandler(self, apiId: int, handler: Callable, checkLease: bool):
self.__apiHandlerMapping[apiId] = (handler, checkLease)
def _RegistBinaryHandler(self, apiId: int, handler: Callable, checkLease: bool):
self.__apiBinaryHandlerMapping[apiId] = (handler, checkLease)
self.__apiBinarySet.add(apiId)
def __GetHandler(self, apiId: int):
if apiId in self.__apiHandlerMapping:
return self.__apiHandlerMapping.get(apiId)
else:
return None, False
def __GetBinaryHandler(self, apiId: int):
if apiId in self.__apiBinaryHandlerMapping:
return self.__apiBinaryHandlerMapping.get(apiId)
else:
return None, False
def __IsBinary(self, apiId):
return apiId in self.__apiBinarySet
def __CheckLeaseDenied(self, leaseId: int):
if (self.__enableLease):
return self.__leaseServer.CheckRequestLeaseDenied(leaseId)
else:
return False
def __ServerRequestHandler(self, request: Request):
parameter = request.parameter
parameterBinary = request.binary
identity = request.header.identity
leaseId = request.header.lease.id
apiId = identity.api_id
code = 0
data = ""
dataBinary = []
if apiId == RPC_API_ID_INTERNAL_API_VERSION:
data = self.__apiVersion
else:
requestHandler = None
binaryRequestHandler = None
checkLease = False
if self.__IsBinary(apiId):
binaryRequestHandler, checkLease = self.__GetBinaryHandler(apiId)
else:
requestHandler, checkLease = self.__GetHandler(apiId)
if requestHandler is None and binaryRequestHandler is None:
code = RPC_ERR_SERVER_API_NOT_IMPL
elif checkLease and self.__CheckLeaseDenied(leaseId):
code = RPC_ERR_SERVER_LEASE_DENIED
else:
try:
if binaryRequestHandler is None:
code, data = requestHandler(parameter)
if code != 0:
data = ""
else:
code, dataBinary = binaryRequestHandler(parameterBinary)
if code != 0:
dataBinary = []
except:
code = RPC_ERR_SERVER_INTERNAL
if request.header.policy.noreply:
return
status = ResponseStatus(code)
response = Response(ResponseHeader(identity, status), data, dataBinary)
self._SendResponse(response)