Python ServerProxy.ping方法代码示例

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import ping [as 别名]
    def test_ROSLaunchNode(self):
        #exercise the basic ROSLaunchNode API
        from roslaunch.server import ROSLaunchNode

        # - create a node with a handler
        handler = TestHandler(self.pmon)
        node = ROSLaunchNode(handler)

        # - start the node
        node.start()
        self.assert_(node.uri)

        # - call the ping API that we added
        s = ServerProxy(node.uri)
        test_val = 'test-%s'%time.time()
        s.ping(test_val)
        self.assertEquals(handler.pinged, test_val)

        # - call the pid API
        code, msg, pid = s.get_pid()
        self.assertEquals(1, code)
        self.assert_(type(msg) == str)
        self.assertEquals(os.getpid(), pid)
        
        # - shut it down
        node.shutdown('test done')

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import ping [as 别名]
class TriggerServer():

    def __init__(self, ip, port, robot_name):
        self._server = Server((ip, port), allow_none=True)
        self._server.register_function(self.get, 'get')
        self._server.register_function(lambda: 'OK', 'ping')
        self._sp  = ServerProxy("http://%s:%d"%(ip,port))

        self._ros_publisher = rospy.Publisher('/%s/trigger'%robot_name, String, queue_size=10)

        self._stop = False

    # RPC METHOD
    def get(self, data):
        self._ros_publisher.publish(String(data=data))

    def serve(self):
        thread.start_new_thread(self._serve, ())
        rospy.spin()
        self._stop = True
        self._sp.ping()

    def _serve(self):
        while not self._stop:
            self._server.handle_request()
        rospy.loginfo("Shutting down TriggerServer")

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import ping [as 别名]
 def stop(self):
     self.server_close()
     self.running = False
     try:
         server = ServerProxy('http://%s:%d' % self.server_address)
         server.ping()
     except:
         pass

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import ping [as 别名]
def connection():
    global video_pool
    try:
        video_pool.ping()
    except Exception, e:
        try:
            video_pool = ServerProxy(o.rpc_url)
            video_pool.ping()
            info({ 'code' : RPC_CONNECT, 'message' : 'Connected to RPC server.'})
        except Exception, e:
            error({ 'code' : RPC_CONNECT_ERR, 'message' : 'Could not connect to RPC server (videocache scheduler) at ' + o.rpc_host + ':' + str(o.rpc_port) + '. Please check scheduler status. If needed, restart scheduler using \'vc-scheduler -s restart\' command.', 'debug' : str(e)})
            trace({ 'code' : RPC_CONNECT_ERR, 'message' : traceback.format_exc() })

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import ping [as 别名]
def connect(url):
    if url == "auto": # Not an URL, but a configuration option
        servers = file(CONFIG_FILENAME, "r").readlines()
        # Randomize the list for load balancing
        random.shuffle(servers)
        
        for server in servers:
            if server == "" or server.startswith("#"):
                continue
            
            s = connect(server)
            
            if s is not None:
                return s
        
        doLog("No server is available!")
        sys.exit(1)
    else:
        url = url.strip("\r").strip("\n")
        s = ServerProxy(url, allow_none=True)
        
        try:
            status = s.ping()
            doLog("Checking server %s status: %s" %(url, status))
            
            if status != "[ALIVE]":
                return None
        except:
            doLog("Error:" + str(sys.exc_info()[1]))
            return None
        
        return s

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import ping [as 别名]
class attk_server(object):
    def __init__(self, password, url):
        self.id = None
        self.password = password
        self.url = url
        self.xml = ServerProxy(self._make_url())

    def _make_url(self):
        url = list(urlsplit(self.url))
        url[1] = 'x:' + self.password + '@' + url[1]
        url[2] = url[2] + 'RPC2'
        return urlunsplit(url)

    def ping(self):
        debug('client pinging server')
        return self.xml.ping() == 'pong'

    def finish_attack(self, attack_id, status):
        debug('client finishing attack with server')
        self.xml.finishAttack(attack_id, config.client_id, status)

    def register(self):
        debug('client registering with server')
        retval = self.xml.registerClient(
            self.password,
            config.client_id,
            config.url,
            config.password,
        )
        if retval is not False:
            self.id = retval

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import ping [as 别名]
class BitcasaClient(object):
    """docstring for BitcasaCore"""

    def __init__(self, _username, _password,
                 _address="127.0.0.1", _port=1664):

        self.address = _address
        self.port = _port
        self.username = _username
        self.password = _password 
        
        # try:
        self.server = ServerProxy("http://" + self.address + ":" + str(self.port))
    
        try:
            log.debug(self.ping())
        except:
             log.critical("Connection to the Bitcasa.py server failed !")
             sys.exit()
        else:
            log.debug("Connected to the server")

    def ping(self):
        return self.server.ping()

    def login(self):
        raise NotImplementedError

    def uploadUrl(self, url):
        raise NotImplementedError
    
    def uploadAllUrl(self):
        raise NotImplementedError

    def uploadFromFileList(self):
        raise NotImplementedError

    def uploadDir(self):
        raise NotImplementedError

    def uploadList(self):
        raise NotImplementedError

    def status(self):
        raise NotImplementedError

    def search(self):
        raise NotImplementedError
    
    def hello(self):
        print self.server.system.listMethods()

    def stopServer(self):
        """
        Yes, it's dirty.
        """
        #try:
        return self.server.stop()

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import ping [as 别名]
def azure_import_publishsetting(args):
    assert isinstance(args, dict)

    if args["user_name"] is None:
        print >> sys.stderr, "No user specified"
        return -1

    if args["publishsetting"] is None:
        print >> sys.stderr, "No publishsetting specified"
        return -1

    s = ServerProxy("http://%s:%d/" % ("172.16.20.248", 12346))
    try:
        socket.setdefaulttimeout(10)
        s.ping()
        socket.setdefaulttimeout(None)
    except Exception as e:
        print >> sys.stderr, "Error: connect azure agent timeout"
        return -1

    try:
        socket.setdefaulttimeout(10)
        r, resp = s.import_publishsettings(args["publishsetting"])
        socket.setdefaulttimeout(None)
        if not r:
            raise
    except Exception as e:
        print >> sys.stderr, "Error: connect azure to import publishsetting failed (%s)" % e
        return -1

    subscription = json.loads(resp)
    subscription["USER"] = args["user_name"]
    subscription_req = json.dumps(subscription)

    r = requests.post(EXCHANGE_URL + "azure-subscriptions/", subscription_req, headers=JSON_HEADER)
    resp = r.json()
    if "OPT_STATUS" not in resp or "DESCRIPTION" not in resp:
        print >> sys.stderr, "Error: response %s corrupted" % resp
        return -1

    if resp["OPT_STATUS"] != "SUCCESS":
        print >> sys.stderr, "Error (%s): %s" % (resp["OPT_STATUS"], resp["DESCRIPTION"])
        return -1

    print "Import publishsetting SUCCESS"

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import ping [as 别名]
def main():
    f = file(CONFIG_FILENAME, "r").readlines()
    for line in f:
        url = line.strip("\r").strip("\n")

	if url == "" or url.startswith("#"):
	    continue

        s = ServerProxy(url)
        
        try:
            status = s.ping()
            doLog("Status of server %s is %s" % (url, status))
        except:
            doLog("Server %s is down: %s" % (url, sys.exc_info()[1]))

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import ping [as 别名]
def do_ping_server():
    http = "http://%s:%s/" % (server, port)

    for i in range(4):
        begin = time.time()
        print "Pinging server %s.. " % (http),

        try:
            client = ServerProxy (http)
            re = client.ping ('ping')
        except:
            print "could not connect"
            time.sleep(1)
            continue

        assert re == 'pong', "Did not receive pong"
        print "%.3f secs" % (time.time() - begin)
        time.sleep(1)

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import ping [as 别名]
    def ping (self):
        """ See if Display server present

        Returns True if server present
        self      = Display object
        """
        from xmlrpclib import ServerProxy
        url = self.serverURL
        if url == "ObitView":
            url = "http://localhost:8765/RPC2"
        server = ServerProxy(url)
        try:
            answer = server.ping(42)
        except:
            answer = False
            pass
        else:
            pass
        if answer:
            print "Display Server "+url+" present"
            return True
        else:
            print "Display Server "+url+" NOT present"
            return False

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import ping [as 别名]
class BattleNode(object):
    def __init__(self, addr):
        self.addr = addr
        self.position = random_pair()
        self._victim = None
        self._victim_addr = None
        self._victim_lock = Lock()
        self.lost = Event()
        self.server = RPCServer(addr,requestHandler=SilentRPCHandler)
        self.server.register_function(self.defend, 'defend')
        self.server.register_function(self.insert, 'insert')
        self.server.register_function(self.ping, 'ping')
        self.server_thread = Thread(target=self.server.serve_forever)
        self.server_thread.daemon = True
        self.server_thread.start()
        self.fail_over = None
        self.loop_event = Event()
        self.loop_thread = Thread(target=self.ping_loop)
        self.loop_thread.daemon = True
        self.loop_thread.start()

    def __eq__(self, other):
        return self.addr == other.addr

    def __ne__(self, other):
        return self.addr != other.addr

    def stop(self):
        self.loop_event.clear()
        self.loop_thread.join()
        self.server.shutdown()
        self.server_thread.join()

    @property
    def victim(self):
        return self._victim_addr

    @victim.setter
    def victim(self, val):
        self._victim_addr = val
        self._victim = ServerProxy('http://{}:{}'.format(*val))
        self.loop_event.set()

    def attack(self, pos=None):
        if pos is None:
            pos = random_pair()
        with self._victim_lock:
            new_victim = tuple(self._victim.defend(pos))
            if new_victim != self.victim:
                self.victim = new_victim
                return True
        return False

    def defend(self, pos):
        if tuple(pos) == self.position:
            self.lost.set()
            return self._victim_addr
        return self.addr

    def insert(self, addr):
        with self._victim_lock:
            old_victim = self._victim_addr
            self.victim = tuple(addr)
            return old_victim

    def join(self, addr):
        attacker = ServerProxy('http://{}:{}'.format(*addr))
        with self._victim_lock:
            self.victim = tuple(attacker.insert(self.addr))

    def ping(self):
        if self.victim:
            return self.victim
        return self.addr

    def ping_victim(self):
        if self.victim:
            try:
                fail_over = tuple(self._victim.ping())
                if fail_over != self.victim:
                    self.fail_over = fail_over
            except IOError:
                if self.loop_event.is_set():
                    self.victim = self.fail_over

    def ping_loop(self):
        self.loop_event.wait()
        while self.loop_event.is_set():
            time.sleep(0.1)
            with self._victim_lock:
                self.ping_victim()

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import ping [as 别名]
class Proxy(object):
    """Wrap ServerProxy with logic and object proxies

    The proxy mirrors the remote interface to provide an
    as-similar experience as possible.

    """

    _instance = None

    def __getattr__(self, attr):
        """Any call not overloaded, simply pass it on"""
        return getattr(self._proxy, attr)

    def __init__(self, port, user=None, password=None):
        self.cached_context = list()
        self.cached_discover = list()

        transport = Transport()

        self._proxy = ServerProxy(
            "http://{auth}127.0.0.1:{port}/pyblish".format(
                port=port,
                auth=("{user}:{pwd}@".format(
                    user=user, pwd=password)
                ) if user else ""),
            allow_none=True,
            transport=transport)

    def test(self, **vars):
        """Vars can only be passed as a non-keyword argument"""
        return self._proxy.test(vars)

    def ping(self):
        """Convert Fault to True/False"""
        try:
            self._proxy.ping()
        except (socket.timeout, socket.error):
            return False
        return True

    def process(self, plugin, context, instance=None, action=None):
        """Transmit a `process` request to host

        Arguments:
            plugin (PluginProxy): Plug-in to process
            context (ContextProxy): Filtered context
            instance (InstanceProxy, optional): Instance to process
            action (str, optional): Action to process

        """

        plugin = plugin.to_json()
        instance = instance.to_json() if instance is not None else None
        return self._proxy.process(plugin, instance, action)

    def repair(self, plugin, context, instance=None):
        plugin = plugin.to_json()
        instance = instance.to_json() if instance is not None else None
        return self._proxy.repair(plugin, instance)

    def context(self):
        self.cached_context = ContextProxy.from_json(self._proxy.context())
        return self.cached_context

    def discover(self):
        self.cached_discover[:] = list()
        for plugin in self._proxy.discover():
            self.cached_discover.append(PluginProxy.from_json(plugin))

        return self.cached_discover

    def emit(self, signal, **kwargs):
        self._proxy.emit(signal, kwargs)

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import ping [as 别名]
client = ServerProxy ("http://217.116.6.26:8002/")
client = ServerProxy ("http://127.0.0.1:8002/")

# INFO
print 'Method info()'
re = client.info ()
assert re != None
print '\tInfo:', re

# PING
print '\nMethod ping()'
for i in range(4):
    begin = time.time()
    print "\tPinging server.. " ,

    re = client.ping ()

    print "%.3f secs" % (time.time() - begin)
    time.sleep(1)

# SEARCH
print '\nMethod search()'
search = {'creator_id':1} # search by dictionary
re = client.search (search)
assert type(re)==list
print '\tSearch results:', re

# GET
print '\nMethod get()'
if not len(re):
    print '\tCould not test method. No previous results'