def get_server(self):
"""
Tries to find the best available server given the config and sets self._current_server for later use.
Returns the first connectible server.
"""
# Use the API or bench to get the best one.
if not len(self.initial_servers_list):
self.full_servers_list = bismuthapi.get_wallet_servers_legacy(self.initial_servers_list, self.app_log, minver='0.1.5', as_dict=True)
self.servers_list=["{}:{}".format(server['ip'], server['port']) for server in self.full_servers_list]
else:
self.servers_list = self.initial_servers_list
self.full_servers_list = [{"ip": server.split(':')[0], "port": server.split(':')[1],
'load':'N/A', 'height': 'N/A'}
for server in self.servers_list]
# Now try to connect
if self.verbose:
print("self.servers_list", self.servers_list)
for server in self.servers_list:
if self.verbose:
print("test server", server)
if lwbench.connectible(server):
self._current_server = server
# TODO: if self._loop, use async version
if self.verbose:
print("connect server", server)
self._connection = rpcconnections.Connection(server, verbose=self.verbose)
return server
self._current_server = None
self._connection = None
# TODO: raise
return None
def connect():
if 'regnet' in config.version:
port = 3030
elif 'testnet' in config.version:
port = 2829
else:
port = 5658
return rpcconnections.Connection(("127.0.0.1", int(port)))
def set_server(self, ipport):
"""
Tries to connect and use the given server
:param ipport:
:return:
"""
if not lwbench.connectible(ipport):
self._current_server = None
self._connection = None
return False
self._current_server = ipport
# TODO: if self._loop, use async version
if self.verbose:
print("connect server", ipport)
self._connection = rpcconnections.Connection(ipport, verbose=self.verbose)
return ipport
def time_measure(light_ip_list, app_log=None):
"""
Measure answer time for the servers in light_ip list
:param light_ip_list: a list of "ip:port" wallet servers
:param app_log: an optional logger
:return: A sorted light_ip list
"""
if not app_log:
app_log = logging
port = DEFAULT_PORT
result_collection = {ip: [0, 0] for ip in light_ip_list}
rpcconnections.LTIMEOUT = 3
for address in result_collection:
try:
ip, local_port = convert_ip_port(address, port)
app_log.info("Attempting to benchmark {}:{}".format(
ip, local_port))
client = rpcconnections.Connection("{}:{}".format(ip, local_port))
if local_port == DEFAULT_PORT: #doesn't work if a node uses non standard port, bench in else-path - will fail
#start benchmark
timer_start = time.time()
result = client.command("statusget")
timer_result = (
time.time() - timer_start
) * 5 #penalty to prio Wallet-Servers before nodes. local node should be so fast, to be still fastest, else it is better that a wallet-server is chosen!
result_collection[address] = timer_result, result[8][7]
app_log.warning(
"Result for {}:{}, a normal node, penalty-factor *5 (real result time/5): {}"
.format(ip, local_port, timer_result))
#finish benchmark
else:
#start benchmark
timer_start = time.time()
result = client.command("statusget")
result_ws = client.command("wstatusget")
timer_result = time.time() - timer_start
#finish benchmark and load balance if too many clients
ws_clients = result_ws.get('clients')
if ws_clients > 300:
timer_result = timer_result + ws_clients / 1000
app_log.warning(
"Result for {}:{}, modified due to high client load: {}"
.format(ip, local_port, timer_result))
elif ws_clients > 150:
timer_result = timer_result + ws_clients / 10000
app_log.warning(
"Result for {}:{}, modified due to client load: {}".
format(ip, local_port, timer_result))
else:
app_log.warning(
"Result for {}:{}, low load - unmodified: {}".format(
ip, local_port, timer_result))
result_collection[address] = timer_result, result[8][7]
except Exception as e:
app_log.warning("Cannot benchmark {}:{}".format(ip, local_port))
# sort IPs for measured Time
bench_result = collections.OrderedDict(
sorted((value[0], key) for (key, value) in result_collection.items()))
light_ip = list(bench_result.values())
max_height_temp = list(result_collection.values())
max_height = max(list(zip(*max_height_temp))[1])
for key, value in result_collection.items():
if int(value[1]) < (max_height - 5):
try:
light_ip.remove(key)
light_ip.append(key)
except Exception as e:
pass
return light_ip