Python ServerProxy.getUri方法代码示例

# 需要导入模块: from xmlrpc.client import ServerProxy [as 别名]
# 或者: from xmlrpc.client.ServerProxy import getUri [as 别名]

#.........这里部分代码省略.........
            self.apiError(self.node.getSubscriptions(self.caller_id, 'something extra'))        
        except Fault:
            pass

    ## validate node.paramUpdate(caller_id, key, value)
    def test_paramUpdate(self):
        node = self.node
        good_key = rosgraph.names.ns_join(self.ns, 'good_key')
        bad_key = rosgraph.names.ns_join(self.ns, 'bad_key')
        
        # node is not subscribed to good_key (yet)
        self.apiError(node.paramUpdate(self.caller_id, good_key, 'good_value'))

        # test bad key
        self.apiError(node.paramUpdate(self.caller_id, '', 'bad'))
        self.apiError(node.paramUpdate(self.caller_id, 'no_namespace', 'bad'))

        # test with bad arity: accept error or fault
        try:
            self.apiError(node.paramUpdate(self.caller_id, bad_key))     
        except Fault:
            pass

        try:
            self.apiError(node.paramUpdate(self.caller_id)) 
        except Fault:
            pass

        # we can't actually test success cases without forcing node to subscribe
        #self.apiSuccess(node.paramUpdate(self.caller_id, good_key, 1))
        #self.apiSuccess(node.paramUpdate(self.caller_id, good_key, True))
        #self.apiSuccess(node.paramUpdate(self.caller_id, good_key, 10.0))

    def xtest_getUri(self):
        """
        Future: validate node.getUri(caller_id).  It would be nice to
        make this official API as it provides some debugging info.
        """
        # test success
        self.check_uri(self.apiSuccess(self.node.getUri(self.caller_id)))
        
        # test bad arity
        try:
            self.apiError(self.node.getUri(self.caller_id, 'bad'))
        except Fault:
            pass
        try:
            self.apiError(self.node.getUri())
        except Fault:
            pass
            
    def test_getMasterUri(self):
        """
        validate node.getMasterUri(caller_id)                
        """
        # test success
        uri = self.apiSuccess(self.node.getMasterUri(self.caller_id))
        self.check_uri(uri)

        # check against env, canonicalize for comparison
        import urlparse
        master_env = rosgraph.get_master_uri()
        if not master_env.endswith('/'):
            master_env = master_env + '/'
        self.assertEquals(urlparse.urlparse(master_env), urlparse.urlparse(uri))

# 需要导入模块: from xmlrpc.client import ServerProxy [as 别名]
# 或者: from xmlrpc.client.ServerProxy import getUri [as 别名]

#.........这里部分代码省略.........
    def hasParam(self, key):
        """
        Check if parameter is stored on server. 
        @param key: parameter to check
        @type  key: str
        @return: [code, statusMessage, hasParam]
        @rtype: [int, str, bool]
        """
        return self._succeed(self.handle.hasParam(self.caller_id, key))

    def getParamNames(self):
        """
        Get list of all parameter names stored on this server.
        This does not adjust parameter names for caller's scope.
        
        @return: [code, statusMessage, parameterNameList]
        @rtype: [int, str, [str]]
        """
        return self._succeed(self.handle.getParamNames(self.caller_id))     
            
        
    ################################################################################
        
    def getPid(self):
        """
        Get the PID of this server
        @return: serverProcessPID
        @rtype: int
        @raise rosgraph.masterapi.Error: if Master returns ERROR.
        @raise rosgraph.masterapi.Failure: if Master returns FAILURE.
        """
        return self._succeed(self.handle.getPid(self.caller_id))

    def getUri(self):
        """
        Get the URI of this Master
        @return: masterUri
        @rtype: str
        @raise rosgraph.masterapi.Error: if Master returns ERROR.
        @raise rosgraph.masterapi.Failure: if Master returns FAILURE.
        """
        return self._succeed(self.handle.getUri(self.caller_id))
    
    def registerService(self, service, service_api, caller_api):
        """
        Register the caller as a provider of the specified service.
        @param service str: Fully-qualified name of service 
        @param service_api str: Service URI 
        @param caller_api str: XML-RPC URI of caller node 
        @return: ignore
        @rtype: int
        @raise rosgraph.masterapi.Error: if Master returns ERROR.
        @raise rosgraph.masterapi.Failure: if Master returns FAILURE.
        """        
        return self._succeed(self.handle.registerService(self.caller_id, service, service_api, caller_api))
    
    def lookupService(self, service):
        """
        Lookup all provider of a particular service.
        @param service: fully-qualified name of service to lookup.
        @type: service: str
        @return (int, str, str): (code, message, serviceUrl). service URL is provides
           and address and port of the service.  Fails if there is no provider.
        @raise rosgraph.masterapi.Error: if Master returns ERROR.
        @raise rosgraph.masterapi.Failure: if Master returns FAILURE.
        """