Python ServerProxy.get_new_hosts方法代码示例

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import get_new_hosts [as 别名]
    def setUp(self):
        yield base.TestBase.setUp(self, "peer0.conf")
        peering.load_keys()

        # Start peer servers
        cwd = os.path.join(os.getcwd(), "..")
        log.msg("Cleaning peer servers...")
        peer1=subprocess.Popen("PYTHONPATH=. scripts/denyhosts-server -c tests/peer1.conf --recreate-database --force > /dev/null 2>&1", cwd=cwd, shell=True)
        peer2=subprocess.Popen("PYTHONPATH=. scripts/denyhosts-server -c tests/peer2.conf --recreate-database --force > /dev/null 2>&1", cwd=cwd, shell=True)
        peer1.wait()
        peer2.wait()

        log.msg("Starting peer servers...")
        self.peer1=subprocess.Popen("PYTHONPATH=. scripts/denyhosts-server -c tests/peer1.conf >/dev/null 2>&1", cwd=cwd, shell=True, preexec_fn=os.setsid)
        self.peer2=subprocess.Popen("PYTHONPATH=. scripts/denyhosts-server -c tests/peer2.conf >/dev/null 2>&1", cwd=cwd, shell=True, preexec_fn=os.setsid)

        log.msg("Waiting until peer servers are responsive...")
        for peer_url in config.peers:
            server = ServerProxy(peer_url)
            is_up = False
            start_time = time.time()
            while not is_up and time.time() - start_time < 10:
                try:
                    server.get_new_hosts(time.time(), 1, [], 3600)
                    is_up = True
                    log.msg("Peer {} is up!".format(peer_url))
                except:
                    time.sleep(0.2)
            if not is_up:
                self.fail("Failed to start peer {}".format(peer_url))

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import get_new_hosts [as 别名]
 def test_send_update_to_peers(self):
     yield peering.send_update("11.11.11.11", time.time(), ["1.1.1.1"])
     yield task.deferLater(reactor, 1.0, lambda _:0, 0)
     for peer_url in config.peers:
         server = ServerProxy(peer_url)
         response = server.get_new_hosts(time.time() - 15, 1, [], 0)
         log.msg("Peer {} has new hosts {}".format(peer_url, response))
         self.assertIn("1.1.1.1", response["hosts"], "Peer did not receive hosts!")

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import get_new_hosts [as 别名]
class Sync(object):
    def __init__(self, prefs):
        self.__prefs = prefs
        self.__work_dir = prefs.get('WORK_DIR')
        self.__connected = False
        self.__hosts_added = []

    def xmlrpc_connect(self):
        try:
            self.__server = ServerProxy(self.__prefs.get('SYNC_SERVER'))
            self.__connected = True
        except Exception as e:
            error(str(e))
            self.__connected = False
        return self.__connected

    def xmlrpc_disconnect(self):
        if self.__connected:
            try:
                #self.__server.close()
                self.__server = None
            except Exception:
                pass
            self.__connected = False

    def get_sync_timestamp(self):
        try:
            fp = open(os.path.join(self.__work_dir,
                                   SYNC_TIMESTAMP))
            timestamp = fp.readline()
            timestamp = int(timestamp.strip())
            return timestamp
        except Exception as e:
            error(str(e))
            return 0

    def set_sync_timestamp(self, timestamp):
        try:
            fp = open(os.path.join(self.__work_dir,
                                   SYNC_TIMESTAMP), "w")
            fp.write(timestamp)
        except Exception as e:
            error(e)

    def send_new_hosts(self):
        debug("send_new_hosts()")
        self.__hosts_added = []
        try:
            src_file = os.path.join(self.__work_dir, SYNC_HOSTS)
            dest_file = os.path.join(self.__work_dir, SYNC_HOSTS_TMP)
            os.rename(src_file, dest_file)
        except OSError:
            return False

        hosts = []
        fp = open(dest_file, "r")
        for line in fp.readlines():
            hosts.append(line.strip())
        fp.close()

        try:
            self.__send_new_hosts(hosts)
            info("sent %d new host%s", len(hosts), get_plural(hosts))
            self.__hosts_added = hosts
        except Exception:
            os.rename(dest_file, src_file)
            return False

        try:
            os.unlink(dest_file)
        except OSError:
            pass

        return True

    def __send_new_hosts(self, hosts):
        if not self.__connected and not self.xmlrpc_connect():
            error("Could not initiate xmlrpc connection")
            return

        try:
            self.__server.add_hosts(hosts)
        except Exception as e:
            exception(e)

    def receive_new_hosts(self):
        debug("receive_new_hosts()")

        if not self.__connected and not self.xmlrpc_connect():
            error("Could not initiate xmlrpc connection")
            return
        timestamp = self.get_sync_timestamp()

        try:
            data = self.__server.get_new_hosts(timestamp,
                self.__prefs.get("SYNC_DOWNLOAD_THRESHOLD"),
                                               self.__hosts_added,
                self.__prefs.get("SYNC_DOWNLOAD_RESILIENCY"))
            timestamp = data['timestamp']
            self.set_sync_timestamp(timestamp)
#.........这里部分代码省略.........