Provider-level caching for historic requests (#4195)

* Provider-level caching for historic requests

* LRUCache

* Adjust

* Adjust

* Adjust

* Opts

* private variables

* Implementation link

* lru .entries adjustment (using .keys)

* Adjust expectations
This commit is contained in:
Jaco
2021-11-10 14:46:13 +02:00
committed by GitHub
parent 0d0a230c86
commit 5e1670dbae
8 changed files with 218 additions and 11 deletions
+20 -1
View File
@@ -8,6 +8,7 @@ import { fetch } from '@polkadot/x-fetch';
import { RpcCoder } from '../coder';
import defaults from '../defaults';
import { LRUCache } from '../lru';
const ERROR_SUBSCRIBE = 'HTTP Provider does not have subscriptions, use WebSockets instead';
@@ -34,6 +35,8 @@ const l = logger('api-http');
* @see [[WsProvider]]
*/
export class HttpProvider implements ProviderInterface {
readonly #callCache = new LRUCache();
readonly #coder: RpcCoder;
readonly #endpoint: string;
@@ -103,8 +106,24 @@ export class HttpProvider implements ProviderInterface {
/**
* @summary Send HTTP POST Request with Body to configured HTTP Endpoint.
*/
public async send <T> (method: string, params: unknown[]): Promise<T> {
public async send <T> (method: string, params: unknown[], isCacheable?: boolean): Promise<T> {
const body = this.#coder.encodeJson(method, params);
let resultPromise: Promise<T> | null = isCacheable
? this.#callCache.get(body) as Promise<T>
: null;
if (!resultPromise) {
resultPromise = this.#send(body);
if (isCacheable) {
this.#callCache.set(body, resultPromise);
}
}
return resultPromise;
}
async #send <T> (body: string): Promise<T> {
const response = await fetch(this.#endpoint, {
body,
headers: {
+49
View File
@@ -0,0 +1,49 @@
// Copyright 2017-2021 @polkadot/rpc-provider authors & contributors
// SPDX-License-Identifier: Apache-2.0
import { LRUCache } from './lru';
describe('LRUCache', (): void => {
it('allows getting of items below capacity', (): void => {
const keys = ['1', '2', '3', '4'];
const lru = new LRUCache(4);
keys.forEach((k) => lru.set(k, `${k}${k}${k}`));
expect(lru.keys().join(', ')).toEqual(keys.reverse().join(', '));
keys.forEach((k) => expect(lru.get(k)).toEqual(`${k}${k}${k}`));
});
it('drops items when at capacity', (): void => {
const keys = ['1', '2', '3', '4', '5', '6'];
const lru = new LRUCache(4);
keys.forEach((k) => lru.set(k, `${k}${k}${k}`));
expect(lru.keys().join(', ')).toEqual(keys.slice(2).reverse().join(', '));
keys.slice(2).forEach((k) => expect(lru.get(k)).toEqual(`${k}${k}${k}`));
});
it('adjusts the order as they are used', (): void => {
const keys = ['1', '2', '3', '4', '5'];
const lru = new LRUCache(4);
keys.forEach((k) => lru.set(k, `${k}${k}${k}`));
expect(lru.entries()).toEqual([['5', '555'], ['4', '444'], ['3', '333'], ['2', '222']]);
lru.get('3');
expect(lru.entries()).toEqual([['3', '333'], ['5', '555'], ['4', '444'], ['2', '222']]);
lru.set('4', '4433');
expect(lru.entries()).toEqual([['4', '4433'], ['3', '333'], ['5', '555'], ['2', '222']]);
lru.set('6', '666');
expect(lru.entries()).toEqual([['6', '666'], ['4', '4433'], ['3', '333'], ['5', '555']]);
});
});
+120
View File
@@ -0,0 +1,120 @@
// Copyright 2017-2021 @polkadot/rpc-provider authors & contributors
// SPDX-License-Identifier: Apache-2.0
const DEFAULT_CAPACITY = 2048;
class LRUNode {
public readonly key: string;
public next: LRUNode;
public prev: LRUNode;
constructor (key: string) {
this.key = key;
this.next = this.prev = this;
}
}
// https://en.wikipedia.org/wiki/Cache_replacement_policies#LRU
export class LRUCache {
readonly capacity: number;
readonly #data: Map<string, unknown> = new Map();
readonly #refs: Map<string, LRUNode> = new Map();
#length = 0;
#head: LRUNode = new LRUNode('head');
#tail: LRUNode = new LRUNode('tail');
constructor (capacity = DEFAULT_CAPACITY) {
this.capacity = capacity;
}
get length (): number {
return this.#length;
}
entries (): [string, unknown][] {
const keys = this.keys();
const entries = new Array<[string, unknown]>(keys.length);
for (let i = 0; i < keys.length; i++) {
const key = keys[i];
entries[i] = [key, this.#data.get(key)];
}
return entries;
}
keys (): string[] {
const keys: string[] = [];
if (this.length) {
let curr = this.#head;
while (curr !== this.#tail) {
keys.push(curr.key);
curr = curr.next;
}
keys.push(curr.key);
}
return keys;
}
get <T> (key: string): T | null {
const data = this.#data.get(key);
if (data) {
this.#toFront(key);
return data as T;
}
return null;
}
set <T> (key: string, value: T): void {
if (this.#data.has(key)) {
this.#toFront(key);
} else {
const node = new LRUNode(key);
this.#refs.set(node.key, node);
if (this.length === 0) {
this.#head = this.#tail = node;
} else {
this.#head.prev = node;
node.next = this.#head;
this.#head = node;
}
if (this.#length === this.capacity) {
this.#data.delete(this.#tail.key);
this.#refs.delete(this.#tail.key);
this.#tail = this.#tail.prev;
this.#tail.next = this.#head;
} else {
this.#length += 1;
}
}
this.#data.set(key, value);
}
#toFront (key: string): void {
const ref = this.#refs.get(key);
if (ref && ref !== this.#head) {
ref.prev.next = ref.next;
ref.next.prev = ref.prev;
ref.next = this.#head;
this.#head.prev = ref;
this.#head = ref;
}
}
}
+1 -1
View File
@@ -49,7 +49,7 @@ export interface ProviderInterface {
connect (): Promise<void>;
disconnect (): Promise<void>;
on (type: ProviderInterfaceEmitted, sub: ProviderInterfaceEmitCb): () => void;
send <T = any> (method: string, params: unknown[]): Promise<T>;
send <T = any> (method: string, params: unknown[], isCacheable?: boolean): Promise<T>;
subscribe (type: string, method: string, params: unknown[], cb: ProviderInterfaceCallback): Promise<number | string>;
unsubscribe (type: string, method: string, id: number | string): Promise<boolean>;
}
+25 -7
View File
@@ -7,12 +7,13 @@ import type { JsonRpcResponse, ProviderInterface, ProviderInterfaceCallback, Pro
import EventEmitter from 'eventemitter3';
import { assert, isChildClass, isNull, isUndefined, logger } from '@polkadot/util';
import { assert, isChildClass, isNull, isUndefined, logger, objectSpread } from '@polkadot/util';
import { xglobal } from '@polkadot/x-global';
import { WebSocket } from '@polkadot/x-ws';
import { RpcCoder } from '../coder';
import defaults from '../defaults';
import { LRUCache } from '../lru';
import { getWSErrorString } from './errors';
interface SubscriptionHandler {
@@ -75,6 +76,8 @@ function eraseRecord<T> (record: Record<string, T>, cb?: (item: T) => void): voi
* @see [[HttpProvider]]
*/
export class WsProvider implements ProviderInterface {
readonly #callCache = new LRUCache();
readonly #coder: RpcCoder;
readonly #endpoints: string[];
@@ -260,12 +263,28 @@ export class WsProvider implements ProviderInterface {
* @param params Encoded parameters as applicable for the method
* @param subscription Subscription details (internally used)
*/
public send <T = any> (method: string, params: unknown[], subscription?: SubscriptionHandler): Promise<T> {
public send <T = any> (method: string, params: unknown[], isCacheable?: boolean, subscription?: SubscriptionHandler): Promise<T> {
const body = this.#coder.encodeJson(method, params);
let resultPromise: Promise<T> | null = isCacheable
? this.#callCache.get(body) as Promise<T>
: null;
if (!resultPromise) {
resultPromise = this.#send(body, method, params, subscription);
if (isCacheable) {
this.#callCache.set(body, resultPromise);
}
}
return resultPromise;
}
async #send <T> (json: string, method: string, params: unknown[], subscription?: SubscriptionHandler): Promise<T> {
return new Promise<T>((resolve, reject): void => {
try {
assert(this.isConnected && !isNull(this.#websocket), 'WebSocket is not connected');
const json = this.#coder.encodeJson(method, params);
const id = this.#coder.getId();
const callback = (error?: Error | null, result?: T): void => {
@@ -309,7 +328,7 @@ export class WsProvider implements ProviderInterface {
* ```
*/
public subscribe (type: string, method: string, params: unknown[], callback: ProviderInterfaceCallback): Promise<number | string> {
return this.send<number | string>(method, params, { callback, type });
return this.send<number | string>(method, params, false, { callback, type });
}
/**
@@ -410,11 +429,10 @@ export class WsProvider implements ProviderInterface {
if (subscription) {
const subId = `${subscription.type}::${result}`;
this.#subscriptions[subId] = {
...subscription,
this.#subscriptions[subId] = objectSpread({}, subscription, {
method,
params
};
});
// if we have a result waiting for this subscription already
if (this.#waitingForId[subId]) {