Python ServerProxy.stop方法代码示例

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import stop [as 别名]
class RPC(object):
    _instance = None

    def __new__(cls, host):
        if not cls._instance:
            cls._instance = object.__new__(cls, host)
        return cls._instance

    def __init__(self, host):
        self.host = host
        host = "localhost"
        self.server = ServerProxy("http://%s:%u" % (host, RPC_PORT))

    def _close(self):
        print "stop"
        self.server.stop()
        del self.server

    @classmethod
    def close(cls):
        print "close", cls._instance
        if not cls._instance:
            return
        cls._instance._close()
        cls._instance = None

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import stop [as 别名]
 def run(self):
     """
     Run the client and perform all the operations:
      * Connect to the server.
      * Receive video while sniffing packets.
      * Close connection.
      * Process data and extract information.
      * Run meters.
     
     :returns: A list of measures (see :attr:`VideoTester.measures.core.Meter.measures`) and the path to the temporary directory plus files prefix: ``<path-to-tempdir>/<prefix>``.
     :rtype: tuple
     """
     VTLOG.info("Client running!")
     VTLOG.info("XMLRPC Server at " + self.conf['ip'] + ':' + self.conf['port'])
     VTLOG.info("Evaluating: " + self.conf['video'] + " + " + self.conf['codec'] + " at " + self.conf['bitrate'] + " kbps and " + self.conf['framerate'] + " fps under " + self.conf['protocols'])
     from xmlrpclib import ServerProxy
     from scapy.all import rdpcap
     from multiprocessing import Process, Queue
     from VideoTester.gstreamer import RTSPclient
     from VideoTester.sniffer import Sniffer
     from VideoTester.measures.qos import QoSmeter
     from VideoTester.measures.bs import BSmeter
     from VideoTester.measures.vq import VQmeter
     try:
         server = ServerProxy('http://' + self.conf['ip'] + ':' + self.conf['port'])
         self.conf['rtspport'] = str(server.run(self.conf['bitrate'], self.conf['framerate']))
     except:
         VTLOG.error("Bad IP or port")
         exit()
     sniffer = Sniffer(self.conf)
     rtspclient = RTSPclient(self.conf, self.video)
     q = Queue()
     child = Process(target=sniffer.run, args=(q,))
     try:
         child.start()
         self.__ping()
         rtspclient.receiver()
         sniffer.cap = rdpcap(q.get())
         child.join()
     except KeyboardInterrupt:
         VTLOG.warning("Keyboard interrupt!")
         server.stop(self.conf['bitrate'], self.conf['framerate'])
         child.terminate()
         child.join()
         exit()
     server.stop(self.conf['bitrate'], self.conf['framerate'])
     videodata, size = rtspclient.reference()
     conf = {'codec':self.conf['codec'], 'bitrate':float(self.conf['bitrate']), 'framerate':float(self.conf['framerate']), 'size':size}
     packetdata = sniffer.parsePkts()
     codecdata, rawdata = self.__loadData(videodata, size, self.conf['codec'])
     qosm = QoSmeter(self.conf['qos'], packetdata).run()
     bsm = BSmeter(self.conf['bs'], codecdata).run()
     vqm = VQmeter(self.conf['vq'], (conf, rawdata, codecdata, packetdata)).run()
     self.__saveMeasures(qosm + bsm + vqm)
     VTLOG.info("Client stopped!")
     return qosm + bsm + vqm, self.conf['tempdir'] + self.conf['num']

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import stop [as 别名]
def main():
    
    if len(sys.argv)<2:
        print "usage:"
        print "  ",sys.argv[0]," <ip-address>"
        print ""
        sys.exit(1)
    
    ip = sys.argv[1]
    
    f_out = open("out.py","w")
    
    f_out.write("server={}\n");
    
    server_c = ServerProxy(settings.RPC_SERVER % {"ip":ip})
    server_c.stop_all()
    
    
    
    stats = {}
    for conf in settings.CONFS:
        
        urls = []
        stats_c ={}
    
        for url in settings.URLS[conf]:
            urls.append(url % {"ip":ip})
            
        
        for server in settings.SERVERS:
            print_banner(server,conf)
        
            print "sleeping 10 seconds to let the server settle down"
            time.sleep(10);
            print "sleep done"
            print ""
            
            s_stats = ab_perf.ab_benchmark(urls,server_c,server,{},conf)
            
            server_c.stop(server)
            
            print s_stats
            
            f_out.write("server['"+server+"_"+conf+"']="+str(s_stats)+"\n")
            
            stats_c[server]=s_stats
            
            
    
        stats[conf]=stats_c
        
    f_out.close()

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import stop [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 stop [as 别名]
class Isabelle_Session:

  def __init__(self, xmlRpcUrl, filename):
    self._isabelle = ServerProxy(xmlRpcUrl).Isabelle
    self._session_key = self._isabelle.start(TIMEOUT, ARGS,
                        "/home/carst/Build/Isabelle2009-2", "")
    self._isabelle.begin_document(filename, self._session_key)

  def __del__(self):
    self._isabelle.stop(self._session_key)

  def add(self, contents):
    self._isabelle.add(contents, self._session_key)

  def document_as_xml(self):
    return self._isabelle.document_as_xml(self._session_key)

  def is_correct(self):
    return self._isabelle.is_correct(self._session_key)

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import stop [as 别名]
    def run(self):
        '''
        Run the client and perform all the operations:
         * Connect to the server.
         * Receive video while sniffing packets.
         * Close connection.
         * Process data and extract information.
         * Run measures.

        :returns: A dictionary of video files received (see :attr:`VideoTester.gstreamer.RTSPClient.files`), a dictionary of caps (see :attr:`VideoTester.gstreamer.RTSPClient.caps`) and a list of results
        :rtype: list
        '''
        VTLOG.info('Client running!')
        try:
            tempdir, num = self.__get_tempdir()
            server = ServerProxy('http://%s:%s' % (self.conf['ip'], self.port))
            rtspport = server.run(self.conf['bitrate'], self.conf['framerate'])
        except Exception as e:
            VTLOG.error(e)
            return None
        VTLOG.info('Connected to XMLRPC Server at %s:%s' % (self.conf['ip'], self.port))
        VTLOG.info('Evaluating: %s, %s, %s kbps, %s fps, %s' % (self.conf['video'], self.conf['codec'], self.conf['bitrate'], self.conf['framerate'], self.conf['protocol']))

        sniffer = Sniffer(self.conf['iface'],
                          self.conf['ip'],
                          '%s%s.cap' % (tempdir, num))
        rtspclient = RTSPClient(
            tempdir + num,
            self.conf['codec'],
            self.conf['bitrate'],
            self.conf['framerate']
        )
        url = 'rtsp://%s:%s/%s.%s' % (
			self.conf['ip'],
			rtspport,
			self.conf['video'],
			self.conf['codec']
		)
        child = Process(target=sniffer.run)
        ret = True
        try:
            child.start()
            VTLOG.info('PID: %s | Sniffer started' % child.pid)
            time.sleep(1)
            rtspclient.receive(url, self.conf['protocol'])
        except KeyboardInterrupt:
            VTLOG.warning('Keyboard interrupt!')
        except Exception as e:
            VTLOG.error(e)
        else:
            ret = False
        server.stop(self.conf['bitrate'], self.conf['framerate'])
        child.terminate()
        child.join()
        VTLOG.info('PID: %s | Sniffer stopped' % child.pid)
        if ret:
            return None

        video = '/'.join([self.path, dict(self.videos)[self.conf['video']]])
        rtspclient.makeReference(video)
        conf = {
            'codec': self.conf['codec'],
            'bitrate': self.conf['bitrate'],
            'framerate': self.conf['framerate'],
            'caps': rtspclient.caps
        }
        packetdata = sniffer.parsePkts(self.conf['protocol'], rtspclient.caps)
        codecdata, rawdata = self.__parseVideo(
            rtspclient.files, rtspclient.caps, self.conf['codec'])

        results = []
        results.extend(QoSmeter(self.conf['qos'], packetdata).run())
        results.extend(BSmeter(self.conf['bs'], codecdata).run())
        results.extend(VQmeter(self.conf['vq'], (conf, rawdata, codecdata, packetdata)).run())

        VTLOG.info('Saving measures...')
        for measure in results:
            f = open(tempdir + num + '_' + measure['name'] + '.pkl', 'wb')
            pickle.dump(measure, f)
            f.close()
        VTLOG.info('Client stopped!')

        return rtspclient.files, rtspclient.caps, results