def __init__(self, manager, userID, converter):
""" Initialize the Converter monitor.
@param manager: Manager which is used in this node and
implements necessary callback.
@type manager: core.manager._RobotManager
@param userID: User ID of the interface owner.
@type userID: str
@param converter: Converter instance which describes converter
which should be monitored.
@type converter: core.interfaces.IEndpointConverterCommand
@raise: util.interfaces.InterfaceError
"""
verifyObject(IEndpointConverterCommand, converter)
super(_ConverterMonitor, self).__init__(userID, converter.tag)
self._msgType = converter.msgType
self._robotID = converter.endpointID
self._converter = manager.converter
self._manager = manager
self._inputMsgCls = None
self._outputMsgCls = None
self._loadClass(manager.loader)
def add(self, producer):
""" Add a new producer to the FIFO.
@raise: util.interfaces.InterfaceError
"""
verifyObject(IRCEProducer, producer)
self._fifo.append((producer, datetime.now()))
def __init__(self, user, robotID, commID, key, control):
""" Initialize the Robot proxy.
@param user: User to which this robot belongs.
@type user: core.user.User
@param robotID: RobotID which is used to identify the robot.
@type robotID: str
@param commID: Communication ID of this robot.
@type commID: str
@param key: Key which should be used to verify connection
from represented robot.
@type key: str
@param control: Control which is used to communicate with the
robot.
@type control: core.interfaces.IRobotControl
"""
verifyObject(IRobotControl, control)
super(RobotProxy, self).__init__(user, robotID, commID, control)
control.createRobot(RobotCommand(robotID, key))
def __init__(self, user, cTag, commID, control):
""" Initialize the Container proxy.
@param user: User instance to which this Container belongs.
@type user: core.user.User
@param control: Control which is used to communicate with the
Container.
@type control: core.interfaces.IContainerControl
@param commID: CommID of the ROS environment inside the
Container.
@type commID: str
@param cTag: Container tag which is used by the user to
identify this Container.
@type cTag: str
"""
verifyObject(IContainerControl, control)
super(ContainerProxy, self).__init__(user, cTag, commID, control)
self._connected = False # TODO: At the moment not used
log.msg('Start container "{0}".'.format(commID))
control.createContainer(ContainerCommand(cTag, commID))
def __init__(self, commMngr, postInit=[], postClose=[]):
""" Initialize the RCEFactory.
@param commMngr: CommManager instance which should be used with
this factory and its build protocols.
@type commMngr: comm.manager.CommManager
@param postInit: Instances which should be informed about the
successful initialization of a connection.
@type postInit: comm.interfaces.IPostInit
@param postClose: Instances which should be informed about the
closing of a connection.
@type postClose: comm.interfaces.IPostClose
@raise: util.interfaces.InterfaceError if the callbacks from
postInit do not implement comm.interfaces.IPostInit
and the callbacks from postClose do not implement
comm.interfaces.IPostClose.
"""
for cb in postInit:
verifyObject(IPostInit, cb)
for cb in postClose:
verifyObject(IPostClose, cb)
self._commManager = commMngr
self._filter = set([types.INIT_REQUEST, types.ROUTE_INFO])
self._postInit = postInit
self._postClose = postClose
def serialize(self, s, msg):
try:
s.addElement(msg['user'])
cmd = msg['cmd']
except KeyError as e:
raise SerializationError('Could not serialize content of '
'Command Message. Missing key: '
'{0}'.format(e))
try:
verifyObject(ISerializable, cmd)
except InterfaceError as e:
raise SerializationError('Content of Command Message can not '
'be serialized: {0}'.format(e))
try:
cls = self._cmdCls[cmd.IDENTIFIER]
except KeyError:
raise SerializationError('The object class is not registered.')
if not isinstance(cmd, cls):
raise SerializationError('The object is of invalid type.')
s.addIdentifier(cmd.IDENTIFIER, 1)
cmd.serialize(s)
def registerControlFactory(self, ctrlFactory):
""" Register the ControlFactory.
@param ctrlFactory: ControlFactory which should be registered.
@type ctrlFactory: core.interfaces.IControlFactory
"""
verifyObject(IControlFactory, ctrlFactory)
self._ctrlFactory = ctrlFactory
def registerLoadBalancer(self, loadBalancer):
""" Register the LoadBalancer.
@param loadBalancer: LoadBalancer which should be registered.
@type loadBalancer: core.interfaces.ILoadBalancer
"""
verifyObject(ILoadBalancer, loadBalancer)
self._loadBalancer = loadBalancer
def onConnect(self, req):
""" Method is called by the Autobahn engine when a request to establish
a connection has been received.
@param req: Connection Request object.
@type req: autobahn.websocket.ConnectionRequest
@raise: autobahn.websocket.HttpException
"""
params = req.params
try:
userID = params['userID']
robotID = params['robotID']
key = params['key']
except KeyError as e:
raise HttpException(httpstatus.HTTP_STATUS_CODE_BAD_REQUEST[0],
'Request is missing parameter: {0}'.format(e))
for name, param in [('userID', userID),
('robotID', robotID),
('key', key)]:
if len(param) != 1:
raise HttpException(httpstatus.HTTP_STATUS_CODE_BAD_REQUEST[0],
"Parameter '{0}' has to be unique in "
'request.'.format(name))
userID = userID[0]
robotID = robotID[0]
key = key[0]
try:
self._manager.robotConnected(userID, robotID, key, self)
except AuthenticationError as e:
raise HttpException(httpstatus.HTTP_STATUS_CODE_FORBIDDEN[0],
str(e))
except Exception as e:
import traceback
raise HttpException(
httpstatus.HTTP_STATUS_CODE_INTERNAL_SERVER_ERROR[0],
traceback.format_exc()
)
self._robotID = robotID
self._userID = userID
# TODO: List should probably not be hard coded here,
# but given as an argument...
for handler in [ CreateContainerHandler(self._manager, userID),
DestroyContainerHandler(self._manager, userID),
ConfigureContainerHandler(self._manager, userID),
ConnectInterfacesHandler(self._manager, userID),
DataMessageHandler(self._manager, userID) ]:
verifyObject(IClientMsgHandler, handler)
self._msgHandler[handler.TYPE] = handler
self._assembler.start()
return None
def registerMessenger(self, messenger):
""" Register the Messenger.
@param messenger: Messenger which should be registered.
@type messenger: core.interfaces.IMessenger
"""
verifyObject(IMessenger, messenger)
if self._messenger:
raise InternalError('There is already a messenger registered.')
self._messenger = messenger
def registerRequestSender(self, sender):
""" Register the RequestSender.
@param sender: RequestSender which should be registered.
@type sender: core.interfaces.IRequestSender
"""
if self._reqSender:
raise InternalError('There is already a RequestSender registered.')
verifyObject(IRequestSender, sender)
self._reqSender = sender
def registerMessageProcessors(self, processors):
""" Method to register a message processor which are used for the
incoming messages. If there already exists a message processor for
the same message type the old message processor is dropped.
@param processors: Processor which should be registered.
@type processors: [ comm.interfaces.IMessageProcessor ]
@raise: util.interfaces.InterfaceError if the processors do not
implement comm.interfaces.IContentSerializer.errors.
"""
for processor in processors:
verifyObject(IMessageProcessor, processor)
self._processors[processor.IDENTIFIER] = processor
def registerContentSerializers(self, serializers):
""" Method to register a content serializer which are used for
serializing/deserializing the messages. If there already exists a
serializer for the same message type the old serializer is dropped.
@param serializers: Content serializers which should be
registered.
@type serializers: [ comm.interfaces.IContentSerializer ]
@raise: util.interfaces.InterfaceError if the serializers do
not implement comm.interfaces.IContentSerializer.
"""
for serializer in serializers:
verifyObject(IContentSerializer, serializer)
self._contentSerializer[serializer.IDENTIFIER] = serializer
def registerControl(self, control):
""" Register control for the communication with the endpoint.
@param control: Control which should be registered for the
communication with the endpoint.
@type control: core.interfaces.IEndpointControl
@raise: errors.InternalError, util.interfaces.InterfaceError
"""
if self._control:
raise InternalError('There is already a control for the '
'communication registered.')
verifyObject(IEndpointControl, control)
self._control = control
def __init__(self, endpoint, tag, iType, msgType, rosAddr=None):
""" Initialize the Interface.
@param endpoint: Endpoint to which this interface belongs.
@type endpoint: core.interfaces.IEndpointProxy
@param tag: Tag which is used to identify this interface.
@type tag: str
@param iType: Interface type; valid values are:
service, publisher, subscriber
@type iType: str
@param msgType: Message type of the form package/messageClass,
i.e. 'std_msgs/Int8'.
@type msgType: str
@param rosAddr: Address which is used for the interface in the
ROS environment, i.e. '/namespace/interface';
only necessary if it is a ROS environment
interface.
@type rosAddr: str / None
@raise: errors.InvalidRequest, util.interfaces.InterfaceError
"""
verifyObject(IEndpointProxy, endpoint)
if iType not in Interface._MAP:
raise InvalidRequest('"{0}" is not a valid interface type.')
self._endpoint = endpoint
self._control = None
self._tag = tag
self._iType = Interface._MAP[iType]
self._msgType = msgType
self._rosAddr = rosAddr
self._conn = set()
endpoint.registerInterface(self)
endpoint.owner.registerInterface(self)
if rosAddr:
try:
endpoint.reserveAddr(rosAddr)
except ValueError:
raise InvalidRequest('Another interface with the same ROS '
'address already exists.')
def __init__(self, manager, userID, interface):
""" Initialize the Interface monitor.
@param manager: Manager which is used in this node and
implements necessary callback.
@type manager: core.manager._InterfaceManager
@param userID: User ID of the interface owner.
@type userID: str
@param interface: Interface instance which describes interface
which should be monitored.
@type interface: IEndpointInterface
@raise: util.interfaces.InterfaceError
"""
verifyObject(IEndpointInterfaceCommand, interface)
super(_InterfaceMonitor, self).__init__(userID, interface.tag)
self._name = interface.name
self._manager = manager
self._ready = False
def __init__(self, manager, userID, forwarder):
""" Initialize the Forwarder monitor.
@param manager: Manager which is used in this node and
implements necessary callback.
@type manager: core.manager._RobotManager
@param userID: User ID of the interface owner.
@type userID: str
@param forwarder: Forwarder instance which describes forwarder
which should be monitored.
@type forwarder: core.interfaces.IEndpointConverterCommand
@raise: util.interfaces.InterfaceError
"""
verifyObject(IEndpointConverterCommand, forwarder)
super(_ForwarderMonitor, self).__init__(userID, forwarder.tag)
self._msgType = forwarder.msgType
self._robotID = forwarder.endpointID
self._manager = manager
def __init__(self, user, uid, commID, control):
""" Initialize the endpoint monitor.
@param user: User to which this endpoint belongs.
@type user: core.user.User
@param uid: Identifier of this endpoint.
@type uid: str
@param commID: Communication ID of this endpoint.
@type commID: str
@param control: Control which is used to send the commands to
the endpoint.
@type control: core.interfaces.IEndpointControl
"""
verifyObject(IEndpointControl, control)
self._user = user
self._uid = uid
self._commID = commID
self._control = control
self._interfaces = set()
def __init__(self, user, tag, commID, control):
""" Initialize the ROS environment proxy.
@param user: User instance to which this ROS environment
belongs.
@type user: core.user.User
@param tag: Tag of this environment.
@type tag: str
@param commID: CommID of the ROS environment.
@type commID: str
@param control: Control which is used to communicate with the
ROS environment.
@type control: core.interfaces.IROSEnvControl
"""
verifyObject(INodeControl, control)
verifyObject(IParameterControl, control)
super(ROSEnvProxy, self).__init__(user, tag, commID, control)
self._rosAddrs = set()
