def cache_class():
return {
generate_cache_key(('fake_endpoint', [1])): (
time.time() - 10,
{'result': 'value-a'},
),
}
def cache_class():
return {
generate_cache_key(('fake_endpoint', [1])): (
time.time() - 10,
{'result': 'value-a'},
),
}
def middleware(method: RPCEndpoint, params: Any) -> RPCResponse:
lock_acquired = lock.acquire(blocking=False)
try:
should_try_cache = (
lock_acquired and
method in rpc_whitelist and
not _is_latest_block_number_request(method, params)
)
if should_try_cache:
_update_block_info_cache()
latest_block_hash = block_info['latest_block']['hash']
cache_key = generate_cache_key((latest_block_hash, method, params))
if cache_key in cache:
return cache[cache_key]
response = make_request(method, params)
if should_cache_fn(method, params, response):
cache[cache_key] = response
return response
else:
return make_request(method, params)
finally:
if lock_acquired:
lock.release()
async def cache_async_session(endpoint_uri: URI, session: ClientSession) -> None:
cache_key = generate_cache_key(endpoint_uri)
with _async_session_cache_lock:
evicted_items = _async_session_cache.cache(cache_key, session)
if evicted_items is not None:
for key, session in evicted_items.items():
await session.close()
def middleware(method: RPCEndpoint, params: Any) -> RPCResponse:
lock_acquired = lock.acquire(blocking=False)
try:
if lock_acquired and method in rpc_whitelist:
cache_key = generate_cache_key((method, params))
if cache_key in cache:
# check that the cached response is not expired.
cached_at, cached_response = cache[cache_key]
cached_for = time.time() - cached_at
if cached_for <= cache_expire_seconds:
return cached_response
else:
del cache[cache_key]
# cache either missed or expired so make the request.
response = make_request(method, params)
if should_cache_fn(method, params, response):
cache[cache_key] = (time.time(), response)
return response
else:
return make_request(method, params)
finally:
if lock_acquired:
lock.release()
def cache_class():
return {
generate_cache_key((current_block_hash, 'eth_getBlockByNumber', [
'latest'
])): {
'result': 'value-a'
},
}
def _get_session(*args, **kwargs):
cache_key = generate_cache_key((args, kwargs))
if cache_key not in _session_cache:
s = requests.Session()
a = HTTPAdapter(max_retries=Retry(connect=5, read=3), pool_connections=64, pool_maxsize=128)
s.mount('https://', a)
s.mount('http://', a)
_session_cache[cache_key] = s
return _session_cache[cache_key]
def _get_session(*args, **kwargs):
cache_key = generate_cache_key((args, kwargs))
if cache_key not in _session_cache:
# This is the main change from original Web3 `_get_session`
session = requests.sessions.Session()
session.mount('http://', HTTPAdapter(pool_connections=25, pool_maxsize=25, pool_block=True))
session.mount('https://',
HTTPAdapter(pool_connections=25, pool_maxsize=25, pool_block=True))
_session_cache[cache_key] = session
return _session_cache[cache_key]
def _get_session_new(*args, **kwargs):
cache_key = generate_cache_key((args, kwargs))
if cache_key not in _session_cache:
_session_cache[cache_key] = requests.Session()
#TODO: Adjust these parameters
retry = Retry(connect=10, backoff_factor=0.3)
adapter = HTTPAdapter(max_retries=retry)
_session_cache[cache_key].mount('http://', adapter)
_session_cache[cache_key].mount('https://', adapter)
return _session_cache[cache_key]
def middleware(method: RPCEndpoint, params: Any) -> RPCResponse:
lock_acquired = lock.acquire(blocking=False)
try:
if lock_acquired and method in rpc_whitelist:
cache_key = generate_cache_key((method, params))
if cache_key not in cache:
response = make_request(method, params)
if should_cache_fn(method, params, response):
cache[cache_key] = response
return response
return cache[cache_key]
else:
return make_request(method, params)
finally:
if lock_acquired:
lock.release()
async def get_async_session(endpoint_uri: URI) -> ClientSession:
cache_key = generate_cache_key(endpoint_uri)
if cache_key not in _async_session_cache:
await cache_async_session(endpoint_uri, ClientSession(raise_for_status=True))
return _async_session_cache.get_cache_entry(cache_key)
def _get_session(*args, **kwargs):
cache_key = generate_cache_key((args, kwargs))
if cache_key not in _session_cache:
_session_cache[cache_key] = requests.Session()
return _session_cache[cache_key]
def cache_class():
return {
generate_cache_key(('fake_endpoint', [1])): {
'result': 'value-a'
},
}
def cache_class():
return {
generate_cache_key((current_block_hash, 'fake_endpoint', [1])): {
'result': 'value-a'
},
}
def cache_class():
return {
generate_cache_key(('fake_endpoint', [1])): {'result': 'value-a'},
}
def get_session(endpoint_uri: URI) -> requests.Session:
cache_key = generate_cache_key(endpoint_uri)
if cache_key not in _session_cache:
_session_cache[cache_key] = requests.Session()
return _session_cache[cache_key]
def cache_session(endpoint_uri: URI, session: requests.Session) -> None:
cache_key = generate_cache_key(endpoint_uri)
_session_cache[cache_key] = session
def test_key_generation_is_deterministic(value):
left = recursive_shuffle_dict(value)
right = recursive_shuffle_dict(value)
left_key = generate_cache_key(left)
right_key = generate_cache_key(right)
assert left_key == right_key
def cache_class():
return {
generate_cache_key(
(current_block_hash, 'fake_endpoint', [1])
): {'result': 'value-a'},
}
