mirror of
https://github.com/LBRYFoundation/hub.git
synced 2025-08-23 17:37:23 +00:00
04d747ff99
deprecates herald options `elastic_host`, `elastic_port`, `elastic_notifier_host`, and `elastic_notifier_port` in favor of the single new `elastic_services` option
166 lines
13 KiB
Python
166 lines
13 KiB
Python
import re
|
|
from collections import deque
|
|
from hub.env import Env
|
|
|
|
ELASTIC_SERVICES_REGEX = re.compile("(([\d|\.]|[^,:\/])*:\d*\/([\d|\.]|[^,:\/])*:\d*,?)*")
|
|
|
|
|
|
def parse_es_services(elastic_services_arg: str):
|
|
match = ELASTIC_SERVICES_REGEX.match(elastic_services_arg)
|
|
if not match:
|
|
return []
|
|
matching = match.group()
|
|
services = [item.split('/') for item in matching.split(',') if item]
|
|
return [
|
|
((es.split(':')[0], int(es.split(':')[1])), (notifier.split(':')[0], int(notifier.split(':')[1])))
|
|
for (es, notifier) in services
|
|
]
|
|
|
|
|
|
class ServerEnv(Env):
|
|
def __init__(self, db_dir=None, max_query_workers=None, chain=None, reorg_limit=None,
|
|
prometheus_port=None, cache_all_tx_hashes=None, cache_all_claim_txos=None,
|
|
daemon_url=None, host=None, elastic_services=None, es_index_prefix=None,
|
|
tcp_port=None, udp_port=None, banner_file=None, allow_lan_udp=None, country=None,
|
|
payment_address=None, donation_address=None, max_send=None, max_receive=None, max_sessions=None,
|
|
session_timeout=None, drop_client=None, description=None, daily_fee=None,
|
|
database_query_timeout=None, blocking_channel_ids=None, filtering_channel_ids=None, peer_hubs=None,
|
|
peer_announce=None, index_address_status=None, address_history_cache_size=None, daemon_ca_path=None,
|
|
merkle_cache_size=None, resolved_url_cache_size=None, tx_cache_size=None,
|
|
history_tx_cache_size=None, largest_address_history_cache_size=None):
|
|
super().__init__(db_dir, max_query_workers, chain, reorg_limit, prometheus_port, cache_all_tx_hashes,
|
|
cache_all_claim_txos, blocking_channel_ids, filtering_channel_ids, index_address_status)
|
|
self.daemon_url = daemon_url if daemon_url is not None else self.required('DAEMON_URL')
|
|
self.host = host if host is not None else self.default('HOST', 'localhost')
|
|
self.elastic_services = deque(parse_es_services(elastic_services or 'localhost:9200/localhost:19080'))
|
|
self.es_index_prefix = es_index_prefix if es_index_prefix is not None else self.default('ES_INDEX_PREFIX', '')
|
|
# Server stuff
|
|
self.tcp_port = tcp_port if tcp_port is not None else self.integer('TCP_PORT', None)
|
|
self.udp_port = udp_port if udp_port is not None else self.integer('UDP_PORT', self.tcp_port)
|
|
self.banner_file = banner_file if banner_file is not None else self.default('BANNER_FILE', None)
|
|
self.allow_lan_udp = allow_lan_udp if allow_lan_udp is not None else self.boolean('ALLOW_LAN_UDP', False)
|
|
self.country = country if country is not None else self.default('COUNTRY', 'US')
|
|
# Peer discovery
|
|
self.peer_discovery = self.peer_discovery_enum()
|
|
self.peer_announce = peer_announce if peer_announce is not None else self.boolean('PEER_ANNOUNCE', True)
|
|
if peer_hubs is not None:
|
|
self.peer_hubs = [p.strip("") for p in peer_hubs.split(",")]
|
|
else:
|
|
self.peer_hubs = self.extract_peer_hubs()
|
|
# The electrum client takes the empty string as unspecified
|
|
self.payment_address = payment_address if payment_address is not None else self.default('PAYMENT_ADDRESS', '')
|
|
self.donation_address = donation_address if donation_address is not None else self.default('DONATION_ADDRESS',
|
|
'')
|
|
# Server limits to help prevent DoS
|
|
self.max_send = max_send if max_send is not None else self.integer('MAX_SEND', 1000000000000000000)
|
|
self.max_receive = max_receive if max_receive is not None else self.integer('MAX_RECEIVE', 1000000000000000000)
|
|
self.max_sessions = max_sessions if max_sessions is not None else self.sane_max_sessions()
|
|
self.session_timeout = session_timeout if session_timeout is not None else self.integer('SESSION_TIMEOUT', 600)
|
|
self.drop_client = re.compile(drop_client) if drop_client is not None else self.custom("DROP_CLIENT", None, re.compile)
|
|
self.description = description if description is not None else self.default('DESCRIPTION', '')
|
|
self.daily_fee = daily_fee if daily_fee is not None else self.string_amount('DAILY_FEE', '0')
|
|
self.database_query_timeout = (database_query_timeout / 1000.0) if database_query_timeout is not None else \
|
|
(float(self.integer('QUERY_TIMEOUT_MS', 10000)) / 1000.0)
|
|
self.hashX_history_cache_size = address_history_cache_size if address_history_cache_size is not None \
|
|
else self.integer('ADDRESS_HISTORY_CACHE_SIZE', 4096)
|
|
self.largest_hashX_history_cache_size = largest_address_history_cache_size if largest_address_history_cache_size is not None \
|
|
else self.integer('LARGEST_ADDRESS_HISTORY_CACHE_SIZE', 256)
|
|
|
|
self.daemon_ca_path = daemon_ca_path if daemon_ca_path else None
|
|
self.merkle_cache_size = merkle_cache_size if merkle_cache_size is not None else self.integer('MERKLE_CACHE_SIZE', 32768)
|
|
self.resolved_url_cache_size = resolved_url_cache_size if resolved_url_cache_size is not None else self.integer(
|
|
'RESOLVED_URL_CACHE_SIZE', 32768)
|
|
self.tx_cache_size = tx_cache_size if tx_cache_size is not None else self.integer(
|
|
'TX_CACHE_SIZE', 32768)
|
|
self.history_tx_cache_size = history_tx_cache_size if history_tx_cache_size is not None else \
|
|
self.integer('HISTORY_TX_CACHE_SIZE', 4194304)
|
|
|
|
@classmethod
|
|
def contribute_to_arg_parser(cls, parser):
|
|
super().contribute_to_arg_parser(parser)
|
|
env_daemon_url = cls.default('DAEMON_URL', None)
|
|
parser.add_argument('--daemon_url', required=env_daemon_url is None,
|
|
help="URL for rpc from lbrycrd or lbcd, "
|
|
"<rpcuser>:<rpcpassword>@<lbrycrd rpc ip><lbrycrd rpc port>.",
|
|
default=env_daemon_url)
|
|
parser.add_argument('--daemon_ca_path', type=str, default='',
|
|
help='Path to the lbcd ca file, used for lbcd with ssl')
|
|
parser.add_argument('--host', type=str, default=cls.default('HOST', 'localhost'),
|
|
help="Interface for hub server to listen on, use 0.0.0.0 to listen on the external "
|
|
"interface. Can be set in env with 'HOST'")
|
|
parser.add_argument('--tcp_port', type=int, default=cls.integer('TCP_PORT', 50001),
|
|
help="Electrum TCP port to listen on for hub server. Can be set in env with 'TCP_PORT'")
|
|
parser.add_argument('--udp_port', type=int, default=cls.integer('UDP_PORT', 50001),
|
|
help="'UDP port to listen on for hub server. Can be set in env with 'UDP_PORT'")
|
|
parser.add_argument('--max_sessions', type=int, default=cls.integer('MAX_SESSIONS', 100000),
|
|
help="Maximum number of electrum clients that can be connected, defaults to 100000.")
|
|
parser.add_argument('--max_send', type=int, default=cls.integer('MAX_SESSIONS', 1000000000000000000),
|
|
help="Maximum size of a request")
|
|
parser.add_argument('--max_receive', type=int, default=cls.integer('MAX_SESSIONS', 1000000000000000000),
|
|
help="Maximum size of a response")
|
|
parser.add_argument('--drop_client', type=str, default=cls.default('DROP_CLIENT', None),
|
|
help="Regex used for blocking clients")
|
|
parser.add_argument('--session_timeout', type=int, default=cls.integer('SESSION_TIMEOUT', 600),
|
|
help="Session inactivity timeout")
|
|
parser.add_argument('--elastic_services',
|
|
default=cls.default('ELASTIC_SERVICES', 'localhost:9200/localhost:19080'), type=str,
|
|
help="Hosts and ports for elastic search and the scribe elastic sync notifier. "
|
|
"Given as a comma separated list without spaces of items in the format "
|
|
"<elastic host>:<elastic port>/<notifier host>:<notifier port> . "
|
|
"Defaults to 'localhost:9200/localhost:19080'. "
|
|
"Can be set in env with 'ELASTIC_SERVICES'")
|
|
parser.add_argument('--es_index_prefix', default=cls.default('ES_INDEX_PREFIX', ''), type=str)
|
|
parser.add_argument('--allow_lan_udp', action='store_true',
|
|
help="Reply to clients on the local network", default=cls.boolean('ALLOW_LAN_UDP', False))
|
|
parser.add_argument('--description', default=cls.default('DESCRIPTION', None), type=str)
|
|
parser.add_argument('--banner_file', default=cls.default('BANNER_FILE', None), type=str)
|
|
parser.add_argument('--country', default=cls.default('COUNTRY', 'US'), type=str)
|
|
parser.add_argument('--payment_address', default=cls.default('PAYMENT_ADDRESS', None), type=str)
|
|
parser.add_argument('--donation_address', default=cls.default('DONATION_ADDRESS', None), type=str)
|
|
parser.add_argument('--daily_fee', default=cls.default('DAILY_FEE', '0'), type=str)
|
|
parser.add_argument('--query_timeout_ms', type=int, default=cls.integer('QUERY_TIMEOUT_MS', 10000),
|
|
help="Elasticsearch query timeout, in ms. Can be set in env with 'QUERY_TIMEOUT_MS'")
|
|
parser.add_argument('--largest_address_history_cache_size', type=int,
|
|
default=cls.integer('LARGEST_ADDRESS_HISTORY_CACHE_SIZE', 256),
|
|
help="Size of the largest value cache for address histories. "
|
|
"Can be set in the env with 'LARGEST_ADDRESS_HISTORY_CACHE_SIZE'")
|
|
parser.add_argument('--address_history_cache_size', type=int,
|
|
default=cls.integer('ADDRESS_HISTORY_CACHE_SIZE', 4096),
|
|
help="Size of the lru cache of address histories. "
|
|
"Can be set in the env with 'ADDRESS_HISTORY_CACHE_SIZE'")
|
|
parser.add_argument('--merkle_cache_size', type=int,
|
|
default=cls.integer('MERKLE_CACHE_SIZE', 32768),
|
|
help="Size of the lru cache of merkle trees for txs in blocks. "
|
|
"Can be set in the env with 'MERKLE_CACHE_SIZE'")
|
|
parser.add_argument('--resolved_url_cache_size', type=int,
|
|
default=cls.integer('RESOLVED_URL_CACHE_SIZE', 32768),
|
|
help="Size of the lru cache of resolved urls. "
|
|
"Can be set in the env with 'RESOLVED_URL_CACHE_SIZE'")
|
|
parser.add_argument('--tx_cache_size', type=int,
|
|
default=cls.integer('TX_CACHE_SIZE', 32768),
|
|
help="Size of the lru cache of transactions. "
|
|
"Can be set in the env with 'TX_CACHE_SIZE'")
|
|
parser.add_argument('--history_tx_cache_size', type=int,
|
|
default=cls.integer('HISTORY_TX_CACHE_SIZE', 524288),
|
|
help="Size of the lfu cache of txids in transaction histories for addresses. "
|
|
"Can be set in the env with 'HISTORY_TX_CACHE_SIZE'")
|
|
|
|
@classmethod
|
|
def from_arg_parser(cls, args):
|
|
return cls(
|
|
db_dir=args.db_dir, daemon_url=args.daemon_url, host=args.host, elastic_services=args.elastic_services,
|
|
max_query_workers=args.max_query_workers, chain=args.chain,
|
|
es_index_prefix=args.es_index_prefix, reorg_limit=args.reorg_limit, tcp_port=args.tcp_port,
|
|
udp_port=args.udp_port, prometheus_port=args.prometheus_port, banner_file=args.banner_file,
|
|
allow_lan_udp=args.allow_lan_udp, cache_all_tx_hashes=args.cache_all_tx_hashes,
|
|
cache_all_claim_txos=args.cache_all_claim_txos, country=args.country, payment_address=args.payment_address,
|
|
donation_address=args.donation_address, max_send=args.max_send, max_receive=args.max_receive,
|
|
max_sessions=args.max_sessions, session_timeout=args.session_timeout,
|
|
drop_client=args.drop_client, description=args.description, daily_fee=args.daily_fee,
|
|
database_query_timeout=args.query_timeout_ms, blocking_channel_ids=args.blocking_channel_ids,
|
|
filtering_channel_ids=args.filtering_channel_ids, index_address_status=args.index_address_statuses,
|
|
address_history_cache_size=args.address_history_cache_size, daemon_ca_path=args.daemon_ca_path,
|
|
merkle_cache_size=args.merkle_cache_size, resolved_url_cache_size=args.resolved_url_cache_size,
|
|
tx_cache_size=args.tx_cache_size, history_tx_cache_size=args.history_tx_cache_size,
|
|
largest_address_history_cache_size=args.largest_address_history_cache_size
|
|
)
|