mirror of
https://github.com/mauriceboe/TREK.git
synced 2026-11-22 13:10:29 +00:00
fix(server): rest the routing relay after a failure and keep it under the installation's minute
A hung TREK Valhalla cost every leg, height chunk and trace the full 30 s before FOSSGIS answered. The relay now waits 10 s for a route or heights, rests a minute after an error or timeout and answers 503 at once meanwhile, follows a 429's Retry-After (an hour at most), passes that header on to the browser, and holds the installation to 100 questions a minute below the gate's 120 (60 per user).
This commit is contained in:
@@ -172,11 +172,12 @@ const FOSSGIS_VALHALLA = 'https://valhalla1.openstreetmap.de';
|
||||
|
||||
/**
|
||||
* What the relay says when it cannot answer for the TREK services right now:
|
||||
* no key, an allowance spent, a body it does not take, a host that is down.
|
||||
* The question then goes to FOSSGIS, as the planner in the browser sends it.
|
||||
* no key, an allowance spent, a body it does not take, a path the host does
|
||||
* not know, a host that is down or resting. The question then goes to
|
||||
* FOSSGIS, as the planner in the browser sends it.
|
||||
*/
|
||||
function relayCannotAnswer(status: number): boolean {
|
||||
return status === 401 || status === 403 || status === 413 || status === 429 || status >= 500;
|
||||
return [401, 403, 404, 405, 413, 429].includes(status) || status >= 500;
|
||||
}
|
||||
|
||||
/** The relay's answer read as the queue reads a router's: the payload, a refusal, or a failure. */
|
||||
|
||||
@@ -45,6 +45,8 @@ export class RoutingRelayController {
|
||||
}
|
||||
}
|
||||
|
||||
/** Of the upstream's headers only Retry-After goes on, so the planner knows how long to ask FOSSGIS instead. */
|
||||
function passOn(res: Response, answer: ValhallaRelayAnswer): void {
|
||||
if (answer.retryAfter) res.set('Retry-After', answer.retryAfter);
|
||||
res.status(answer.status).type(answer.contentType).send(answer.body);
|
||||
}
|
||||
|
||||
@@ -10,17 +10,31 @@ import type { ConfigType } from '@nestjs/config';
|
||||
import { VALHALLA_RELAY_REQUEST_SCHEMAS, compactValhallaRequest, type ValhallaRelayAction } from '@trek/shared';
|
||||
|
||||
/** Questions one user may put to the TREK Valhalla a minute, the browser and the server's own routing together. */
|
||||
const QUESTIONS_PER_MINUTE = 120;
|
||||
const QUESTIONS_PER_MINUTE = 60;
|
||||
/**
|
||||
* Questions the whole installation may put a minute. The TREK services allow
|
||||
* a key 120 calls a minute across their services, so routing stays below
|
||||
* that and leaves the address and place search their share.
|
||||
*/
|
||||
const INSTALLATION_QUESTIONS_PER_MINUTE = 100;
|
||||
const RATE_WINDOW_MS = 60_000;
|
||||
const DEFAULT_TIMEOUT_MS = 30_000;
|
||||
/** Short, because FOSSGIS still has to answer behind it while the planner waits. */
|
||||
const TIMEOUT_MS = 10_000;
|
||||
/** Matching a long line takes Valhalla a while, on FOSSGIS as much as here. */
|
||||
const TRACE_TIMEOUT_MS = 30_000;
|
||||
/** How long every question goes to FOSSGIS after the TREK Valhalla failed one. */
|
||||
const REST_MS = 60_000;
|
||||
/** The longest wait a Retry-After is followed for; the first question after it finds out whether the allowance is back. */
|
||||
const MAX_REST_MS = 60 * 60_000;
|
||||
/** A day with alternates, or the description of a long line, stays far below this. */
|
||||
const MAX_ANSWER_BYTES = 8 * 1024 * 1024;
|
||||
|
||||
/** Valhalla's answer as it came: its status, its content type and its body untouched. */
|
||||
/** Valhalla's answer as it came: its status, its content type, its body untouched and the wait a refusal asks for. */
|
||||
export interface ValhallaRelayAnswer {
|
||||
status: number;
|
||||
contentType: string;
|
||||
body: Buffer;
|
||||
retryAfter?: string;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -30,9 +44,15 @@ export interface ValhallaRelayAnswer {
|
||||
* TREK_SERVICES_HOSTS lists, so a browser never sees the key and a user
|
||||
* cannot send it anywhere else. Every question counts against the user's
|
||||
* allowance here, whichever surface asks it.
|
||||
*
|
||||
* A host that failed a question, or refused it for a spent allowance, is left
|
||||
* alone for a while: the relay then answers 503 at once and every caller asks
|
||||
* FOSSGIS, instead of each leg of a long day waiting out the deadline again.
|
||||
*/
|
||||
@Injectable()
|
||||
export class RoutingRelayService {
|
||||
private restingUntil = 0;
|
||||
|
||||
constructor(
|
||||
@Inject(servicesConfig.KEY) private readonly config: ConfigType<typeof servicesConfig>,
|
||||
private readonly identity: ServiceIdentityPort,
|
||||
@@ -53,7 +73,7 @@ export class RoutingRelayService {
|
||||
userId: number,
|
||||
action: ValhallaRelayAction,
|
||||
body: object,
|
||||
timeoutMs = DEFAULT_TIMEOUT_MS,
|
||||
timeoutMs = action === 'trace_attributes' ? TRACE_TIMEOUT_MS : TIMEOUT_MS,
|
||||
): Promise<ValhallaRelayAnswer> {
|
||||
const parsed = VALHALLA_RELAY_REQUEST_SCHEMAS[action].safeParse(compactValhallaRequest(action, body));
|
||||
if (!parsed.success) {
|
||||
@@ -62,14 +82,26 @@ export class RoutingRelayService {
|
||||
const url = this.endpoint(action);
|
||||
const headers = this.keyHeaders(url);
|
||||
if (!headers) throw new DomainError(503, 'The TREK routing service is not available on this instance');
|
||||
const now = Date.now();
|
||||
if (now < this.restingUntil) {
|
||||
return refusal(503, 'The TREK routing service is resting', this.restingUntil - now);
|
||||
}
|
||||
const allowed = await this.rateLimit.check(
|
||||
'valhalla-relay',
|
||||
String(userId),
|
||||
QUESTIONS_PER_MINUTE,
|
||||
RATE_WINDOW_MS,
|
||||
Date.now(),
|
||||
now,
|
||||
);
|
||||
if (!allowed) throw new DomainError(429, 'Too many routing requests, try again in a minute');
|
||||
const withinInstallation = await this.rateLimit.check(
|
||||
'valhalla-relay-installation',
|
||||
'all',
|
||||
INSTALLATION_QUESTIONS_PER_MINUTE,
|
||||
RATE_WINDOW_MS,
|
||||
now,
|
||||
);
|
||||
if (!withinInstallation) return refusal(429, 'Too many routing requests on this instance', RATE_WINDOW_MS);
|
||||
return this.forward(url, headers, parsed.data, timeoutMs);
|
||||
}
|
||||
|
||||
@@ -93,19 +125,28 @@ export class RoutingRelayService {
|
||||
MAX_ANSWER_BYTES,
|
||||
);
|
||||
this.identity.observe(url, response);
|
||||
const retryAfter = response.headers.get('retry-after');
|
||||
if (response.status === 429) this.rest(waitOf(retryAfter) ?? REST_MS);
|
||||
else if (response.status >= 500) this.rest(REST_MS);
|
||||
const { bytes, truncated } = await readCapped(response, MAX_ANSWER_BYTES);
|
||||
if (truncated) throw new Error('the answer is larger than the relay passes on');
|
||||
return {
|
||||
status: response.status,
|
||||
contentType: response.headers.get('content-type') ?? 'application/json',
|
||||
body: bytes,
|
||||
...(retryAfter ? { retryAfter } : {}),
|
||||
};
|
||||
} catch (err) {
|
||||
this.rest(REST_MS);
|
||||
logWarn(`[Routing relay] ${url.pathname}: ${err instanceof Error ? err.message : String(err)}`);
|
||||
throw new DomainError(502, 'The TREK routing service did not answer');
|
||||
}
|
||||
}
|
||||
|
||||
private rest(ms: number): void {
|
||||
this.restingUntil = Math.max(this.restingUntil, Date.now() + Math.min(ms, MAX_REST_MS));
|
||||
}
|
||||
|
||||
private endpoint(action: ValhallaRelayAction): URL {
|
||||
return new URL(`${this.config.valhallaUrl}/${action}`);
|
||||
}
|
||||
@@ -117,3 +158,22 @@ export class RoutingRelayService {
|
||||
return headers.Authorization ? headers : null;
|
||||
}
|
||||
}
|
||||
|
||||
/** A refusal of the relay's own, in the body the exception filter writes, with the wait it asks for. */
|
||||
function refusal(status: number, error: string, waitMs: number): ValhallaRelayAnswer {
|
||||
return {
|
||||
status,
|
||||
contentType: 'application/json',
|
||||
body: Buffer.from(JSON.stringify({ error })),
|
||||
retryAfter: String(Math.max(1, Math.ceil(waitMs / 1000))),
|
||||
};
|
||||
}
|
||||
|
||||
/** A Retry-After in milliseconds, given as seconds or as an HTTP date; null when there is none to read. */
|
||||
function waitOf(header: string | null): number | null {
|
||||
const value = header?.trim();
|
||||
if (!value) return null;
|
||||
if (/^\d+$/.test(value)) return Number(value) * 1000;
|
||||
const at = Date.parse(value);
|
||||
return Number.isNaN(at) ? null : Math.max(0, at - Date.now());
|
||||
}
|
||||
|
||||
@@ -153,4 +153,23 @@ describe('POST /api/routing/valhalla/:action', () => {
|
||||
expect(res.body).toEqual({ error: 'The TREK routing service is not available on this instance' });
|
||||
expect(safeFetchAdminConfigured).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('RELAY-E2E-007: passes a spent allowance on with its Retry-After, and rests without asking again', async () => {
|
||||
safeFetchAdminConfigured.mockResolvedValue(
|
||||
new Response('{"error":"quota"}', {
|
||||
status: 429,
|
||||
headers: { 'content-type': 'application/json', 'retry-after': '30', 'x-trek-quota-remaining': '0' },
|
||||
}),
|
||||
);
|
||||
const spent = await request(app.getHttpServer()).post('/api/routing/valhalla/route').set(as(USER)).send(ROUTE);
|
||||
expect(spent.status).toBe(429);
|
||||
expect(spent.headers['retry-after']).toBe('30');
|
||||
expect(spent.headers).not.toHaveProperty('x-trek-quota-remaining');
|
||||
|
||||
const resting = await request(app.getHttpServer()).post('/api/routing/valhalla/route').set(as(USER)).send(ROUTE);
|
||||
expect(resting.status).toBe(503);
|
||||
expect(Number(resting.headers['retry-after'])).toBeGreaterThan(0);
|
||||
expect(resting.body).toEqual({ error: 'The TREK routing service is resting' });
|
||||
expect(safeFetchAdminConfigured).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
});
|
||||
|
||||
@@ -731,6 +731,8 @@ describe('server Roadtrip router through the TREK services (routing relay)', ()
|
||||
const refusals = [
|
||||
() => Promise.resolve(answer(429, { error: 'Too many routing requests' })),
|
||||
() => Promise.resolve(answer(502, { error: 'down' })),
|
||||
() => Promise.resolve(answer(503, { error: 'The TREK routing service is resting' })),
|
||||
() => Promise.resolve(answer(404, { error: 'Not Found' })),
|
||||
() => Promise.reject(new DomainError(503, 'The TREK routing service is not available on this instance')),
|
||||
];
|
||||
for (const [userId, refusal] of refusals.entries()) {
|
||||
|
||||
@@ -41,6 +41,17 @@ describe('RoutingRelayController', () => {
|
||||
}
|
||||
});
|
||||
|
||||
it('RELAY-CTRL-003: sends a Retry-After along where the answer names one', async () => {
|
||||
const spent = { ...answer, status: 429, retryAfter: '30' };
|
||||
const controller = new RoutingRelayController({
|
||||
ask: vi.fn().mockResolvedValue(spent),
|
||||
} as unknown as RoutingRelayService);
|
||||
const res = { ...response(), set: vi.fn() };
|
||||
await controller.route(user, { locations: [], costing: 'auto' } as never, res as unknown as Response);
|
||||
expect(res.set).toHaveBeenCalledWith('Retry-After', '30');
|
||||
expect(res.status).toHaveBeenCalledWith(429);
|
||||
});
|
||||
|
||||
it('RELAY-CTRL-002: lets a refusal of the relay itself reach the exception filter', async () => {
|
||||
const refusal = new Error('refused');
|
||||
const controller = new RoutingRelayController({
|
||||
|
||||
@@ -2,7 +2,8 @@
|
||||
* RoutingRelayService: the TREK services' Valhalla asked for a user. The key
|
||||
* goes along only when the identity hands one over for that host, the body is
|
||||
* held to the shared contract, every question counts against the user's
|
||||
* minute, and Valhalla's answer comes back untouched. The upstream behind
|
||||
* and the installation's minute, Valhalla's answer comes back untouched, and
|
||||
* a host that failed is left alone for a while. The upstream behind
|
||||
* safeFetchAdminConfigured is a stub.
|
||||
*/
|
||||
import { servicesConfig } from '../../../../src/nest/app-config/tokens';
|
||||
@@ -37,8 +38,8 @@ const ROUTE = {
|
||||
costing: 'auto',
|
||||
costing_options: { auto: { use_tolls: 0 } },
|
||||
};
|
||||
const upstream = (status: number, body: string, type = 'application/json') =>
|
||||
new Response(body, { status, headers: { 'content-type': type } });
|
||||
const upstream = (status: number, body: string, extra: Record<string, string> = {}) =>
|
||||
new Response(body, { status, headers: { 'content-type': 'application/json', ...extra } });
|
||||
|
||||
const testDb = createSnapshotTestDb();
|
||||
let t: TestModule;
|
||||
@@ -63,6 +64,7 @@ beforeEach(async () => {
|
||||
});
|
||||
|
||||
afterEach(async () => {
|
||||
vi.useRealTimers();
|
||||
await t.close();
|
||||
});
|
||||
|
||||
@@ -120,29 +122,109 @@ describe('RoutingRelayService.ask', () => {
|
||||
expect(safeFetchAdminConfigured).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('RELAY-006: holds every user to 120 questions a minute, each user apart', async () => {
|
||||
it('RELAY-006: holds every user to 60 questions a minute, each user apart', async () => {
|
||||
vi.mocked(safeFetchAdminConfigured).mockImplementation(async () => upstream(200, '{}'));
|
||||
for (let i = 0; i < 120; i++) await relay.ask(1, 'height', { shape: [{ lat: 47, lon: 11 }] });
|
||||
for (let i = 0; i < 60; i++) await relay.ask(1, 'height', { shape: [{ lat: 47, lon: 11 }] });
|
||||
const refused = await relay.ask(1, 'route', ROUTE).catch((err: unknown) => err);
|
||||
expect(refused).toBeInstanceOf(DomainError);
|
||||
expect(refused).toMatchObject({ status: 429, message: 'Too many routing requests, try again in a minute' });
|
||||
expect((await relay.ask(2, 'route', ROUTE)).status).toBe(200);
|
||||
expect(safeFetchAdminConfigured).toHaveBeenCalledTimes(121);
|
||||
expect(safeFetchAdminConfigured).toHaveBeenCalledTimes(61);
|
||||
});
|
||||
|
||||
it('RELAY-007: answers 502 where the host does not answer or sends more than it passes on', async () => {
|
||||
it('RELAY-007: holds the whole installation to 100 questions a minute and says when to come back', async () => {
|
||||
vi.mocked(safeFetchAdminConfigured).mockImplementation(async () => upstream(200, '{}'));
|
||||
const height = { shape: [{ lat: 47, lon: 11 }] };
|
||||
for (let i = 0; i < 60; i++) await relay.ask(1, 'height', height);
|
||||
for (let i = 0; i < 40; i++) await relay.ask(2, 'height', height);
|
||||
const refused = await relay.ask(3, 'route', ROUTE);
|
||||
expect(refused).toMatchObject({ status: 429, retryAfter: '60' });
|
||||
expect(JSON.parse(refused.body.toString())).toEqual({ error: 'Too many routing requests on this instance' });
|
||||
expect(safeFetchAdminConfigured).toHaveBeenCalledTimes(100);
|
||||
});
|
||||
|
||||
it('RELAY-008: answers 502 where the host does not answer or sends more than it passes on', async () => {
|
||||
vi.useFakeTimers({ toFake: ['Date'] });
|
||||
vi.setSystemTime(new Date('2026-10-29T10:00:00Z'));
|
||||
vi.mocked(safeFetchAdminConfigured).mockRejectedValueOnce(new Error('connect ECONNREFUSED'));
|
||||
await expect(relay.ask(1, 'route', ROUTE)).rejects.toMatchObject({
|
||||
status: 502,
|
||||
message: 'The TREK routing service did not answer',
|
||||
});
|
||||
vi.setSystemTime(new Date('2026-10-29T10:01:01Z'));
|
||||
vi.mocked(safeFetchAdminConfigured).mockResolvedValueOnce(upstream(200, 'x'.repeat(8 * 1024 * 1024 + 1)));
|
||||
await expect(relay.ask(1, 'route', ROUTE)).rejects.toMatchObject({ status: 502 });
|
||||
});
|
||||
|
||||
it('RELAY-009: after a host that hung, the next question is answered 503 at once, and asked again after the rest', async () => {
|
||||
vi.useFakeTimers({ toFake: ['Date'] });
|
||||
vi.setSystemTime(new Date('2026-10-29T10:00:00Z'));
|
||||
vi.mocked(safeFetchAdminConfigured).mockRejectedValueOnce(
|
||||
new DOMException('The operation was aborted due to timeout', 'TimeoutError'),
|
||||
);
|
||||
await expect(relay.ask(1, 'height', { shape: [{ lat: 47, lon: 11 }] })).rejects.toMatchObject({ status: 502 });
|
||||
|
||||
const resting = await relay.ask(1, 'height', { shape: [{ lat: 47.1, lon: 11 }] });
|
||||
expect(resting).toMatchObject({ status: 503, retryAfter: '60' });
|
||||
expect(safeFetchAdminConfigured).toHaveBeenCalledTimes(1);
|
||||
|
||||
vi.setSystemTime(new Date('2026-10-29T10:01:01Z'));
|
||||
vi.mocked(safeFetchAdminConfigured).mockResolvedValueOnce(upstream(200, '{}'));
|
||||
expect((await relay.ask(1, 'route', ROUTE)).status).toBe(200);
|
||||
expect(safeFetchAdminConfigured).toHaveBeenCalledTimes(2);
|
||||
});
|
||||
|
||||
it('RELAY-010: passes an error of the host on and rests after it', async () => {
|
||||
vi.mocked(safeFetchAdminConfigured).mockResolvedValueOnce(upstream(504, '{"error":"gateway"}'));
|
||||
expect((await relay.ask(1, 'route', ROUTE)).status).toBe(504);
|
||||
expect((await relay.ask(1, 'route', ROUTE)).status).toBe(503);
|
||||
expect(safeFetchAdminConfigured).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it("RELAY-011: follows a spent allowance's Retry-After, at most an hour of it, and passes it on", async () => {
|
||||
vi.useFakeTimers({ toFake: ['Date'] });
|
||||
vi.setSystemTime(new Date('2026-10-29T10:00:00Z'));
|
||||
vi.mocked(safeFetchAdminConfigured).mockResolvedValueOnce(
|
||||
upstream(429, '{"error":"day"}', { 'retry-after': '50400' }),
|
||||
);
|
||||
expect(await relay.ask(1, 'route', ROUTE)).toMatchObject({ status: 429, retryAfter: '50400' });
|
||||
expect((await relay.ask(1, 'route', ROUTE)).retryAfter).toBe('3600');
|
||||
|
||||
vi.setSystemTime(new Date('2026-10-29T11:00:01Z'));
|
||||
vi.mocked(safeFetchAdminConfigured).mockResolvedValueOnce(
|
||||
upstream(429, '{"error":"minute"}', { 'retry-after': 'Thu, 29 Oct 2026 11:00:21 GMT' }),
|
||||
);
|
||||
expect((await relay.ask(1, 'route', ROUTE)).status).toBe(429);
|
||||
expect((await relay.ask(1, 'route', ROUTE)).retryAfter).toBe('20');
|
||||
|
||||
vi.setSystemTime(new Date('2026-10-29T11:00:22Z'));
|
||||
vi.mocked(safeFetchAdminConfigured).mockResolvedValueOnce(upstream(429, '{}', { 'retry-after': 'soon' }));
|
||||
await relay.ask(1, 'route', ROUTE);
|
||||
expect((await relay.ask(1, 'route', ROUTE)).retryAfter).toBe('60');
|
||||
expect(safeFetchAdminConfigured).toHaveBeenCalledTimes(3);
|
||||
});
|
||||
|
||||
it('RELAY-015: rests a minute after a spent allowance that names no wait, and invents none for it', async () => {
|
||||
vi.mocked(safeFetchAdminConfigured).mockResolvedValueOnce(upstream(429, '{"error":"spent"}'));
|
||||
const spent = await relay.ask(1, 'route', ROUTE);
|
||||
expect(spent.status).toBe(429);
|
||||
expect(spent).not.toHaveProperty('retryAfter');
|
||||
expect((await relay.ask(1, 'route', ROUTE)).retryAfter).toBe('60');
|
||||
});
|
||||
|
||||
it('RELAY-012: waits ten seconds for a route and thirty for a description, unless told otherwise', async () => {
|
||||
const timeout = vi.spyOn(AbortSignal, 'timeout');
|
||||
vi.mocked(safeFetchAdminConfigured).mockImplementation(async () => upstream(200, '{}'));
|
||||
await relay.ask(1, 'route', ROUTE);
|
||||
await relay.ask(1, 'trace_attributes', { encoded_polyline: 'abc', costing: 'pedestrian' });
|
||||
await relay.ask(1, 'height', { shape: [{ lat: 47, lon: 11 }] }, 5000);
|
||||
expect(timeout.mock.calls.map(([ms]) => ms)).toEqual([10_000, 30_000, 5000]);
|
||||
timeout.mockRestore();
|
||||
});
|
||||
});
|
||||
|
||||
describe('RoutingRelayService.trekValhalla and serves', () => {
|
||||
it('RELAY-010: names the TREK Valhalla only while there is a key to take there', () => {
|
||||
it('RELAY-013: names the TREK Valhalla only while there is a key to take there', () => {
|
||||
expect(relay.trekValhalla()).toBe('https://valhalla.liketrek.com');
|
||||
identity.headersFor.mockReturnValueOnce({});
|
||||
expect(relay.trekValhalla()).toBeNull();
|
||||
@@ -150,7 +232,7 @@ describe('RoutingRelayService.trekValhalla and serves', () => {
|
||||
expect(relay.trekValhalla()).toBeNull();
|
||||
});
|
||||
|
||||
it('RELAY-011: knows its own address, with or without a trailing slash, and no other', () => {
|
||||
it('RELAY-014: knows its own address, with or without a trailing slash, and no other', () => {
|
||||
expect(relay.serves('https://valhalla.liketrek.com/')).toBe(true);
|
||||
expect(relay.serves('https://valhalla1.openstreetmap.de')).toBe(false);
|
||||
});
|
||||
|
||||
@@ -51,7 +51,7 @@ The address of an OSRM instance of your own, for example `https://osrm.example.o
|
||||
Which Valhalla answers what OSRM cannot: driving around toll roads, motorways and ferries, and the routes, heights and ways of tours.
|
||||
|
||||
- **Automatic** (nothing chosen): the TREK services, or **Own Valhalla instance** when one is set. If only **Own routing engine** is set, no Valhalla is asked.
|
||||
- **TREK services**: the Valhalla at `valhalla.liketrek.com` (or `TREK_VALHALLA_URL`). This server asks it with the installation key, so the browser never talks to it and no restart is needed. Where it cannot answer (no key yet, the day's allowance spent, the service down, or a shared page without a sign-in), TREK asks the public FOSSGIS Valhalla instead, without a message.
|
||||
- **TREK services**: the Valhalla at `valhalla.liketrek.com` (or `TREK_VALHALLA_URL`). This server asks it with the installation key, so the browser never talks to it and no restart is needed. Where it cannot answer (no key yet, the day's allowance spent, the service down or slow to answer, or a shared page without a sign-in), TREK asks the public FOSSGIS Valhalla instead, without a message. After such an answer it keeps asking FOSSGIS for a while: a minute after an error or a question that took longer than ten seconds, as long as the service says when the allowance is spent (an hour at most). Each user may ask 60 routing questions a minute through this server, and the whole installation 100.
|
||||
- **Public Valhalla (FOSSGIS)**: `valhalla1.openstreetmap.de`, as before.
|
||||
- **Own Valhalla instance**: the address below.
|
||||
|
||||
|
||||
Reference in New Issue
Block a user