mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-20 18:22:25 +00:00
Main's Street View budget tests in the media feed-type file now mount the provider through the shared CCTV test harness, which also resets the Google rate-limit setting.
549 lines
19 KiB
JavaScript
549 lines
19 KiB
JavaScript
// /api/cctv/media is the live-feed relay. A still camera used to be relayed
|
|
// through it as well, by an ordinary redirect-following fetch with no content
|
|
// type check and no body cap, which side-stepped everything /api/cctv/frame
|
|
// enforces for the same URL. These pin that a still is refused there and only
|
|
// reachable through /frame, while live feeds keep their relay.
|
|
//
|
|
// Run with: npm test (node --test)
|
|
import { test } from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { Readable } from 'node:stream';
|
|
import { mountCctvProvider } from '../testSupport/cctvProviderHarness.mjs';
|
|
|
|
const STILL = {
|
|
id: 'still-fixture',
|
|
name: 'Still fixture',
|
|
lat: 30.27,
|
|
lon: -97.74,
|
|
feedType: 'image',
|
|
url: 'https://cams.upstream.invalid/still.jpg',
|
|
};
|
|
// 'jpg' normalizes to 'image'; the alias must not reopen the relay.
|
|
const STILL_ALIAS = {
|
|
...STILL,
|
|
id: 'still-alias',
|
|
feedType: 'jpg',
|
|
url: 'https://cams.upstream.invalid/alias.jpg',
|
|
};
|
|
const VIDEO = {
|
|
id: 'video-fixture',
|
|
name: 'Video fixture',
|
|
lat: 30.27,
|
|
lon: -97.74,
|
|
feedType: 'video',
|
|
url: 'https://cams.upstream.invalid/live.mp4',
|
|
};
|
|
const WEBM = {
|
|
id: 'webm-fixture',
|
|
name: 'WebM fixture',
|
|
lat: 30.27,
|
|
lon: -97.74,
|
|
feedType: 'webm',
|
|
url: 'https://cams.upstream.invalid/live.webm',
|
|
};
|
|
const MJPEG = {
|
|
id: 'mjpeg-fixture',
|
|
name: 'MJPEG fixture',
|
|
lat: 30.27,
|
|
lon: -97.74,
|
|
feedType: 'mjpeg',
|
|
url: 'https://cams.upstream.invalid/live.mjpg',
|
|
};
|
|
|
|
/** A minimal upstream Response with a streaming body. */
|
|
function upstreamResponse({ status = 200, headers = {}, body = 'payload' }) {
|
|
const store = new Map(
|
|
Object.entries(headers).map(([key, value]) => [key.toLowerCase(), value]),
|
|
);
|
|
return {
|
|
ok: status >= 200 && status < 300,
|
|
status,
|
|
headers: { get: (name) => store.get(String(name).toLowerCase()) ?? null },
|
|
body: Readable.toWeb(Readable.from([Buffer.from(String(body))])),
|
|
};
|
|
}
|
|
|
|
/** Mount the real provider over the fixture cameras, recording upstream requests. */
|
|
function mount(t, respond) {
|
|
const requests = [];
|
|
const app = mountCctvProvider(t, {
|
|
cameras: [STILL, STILL_ALIAS, VIDEO, WEBM, MJPEG],
|
|
fetch: async (url, init = {}) => {
|
|
requests.push({ url: String(url), redirect: init.redirect });
|
|
return respond({ url: String(url), init });
|
|
},
|
|
});
|
|
return { ...app, requests };
|
|
}
|
|
|
|
test('a still camera is refused by /media without any upstream request', async (t) => {
|
|
// Everything the old relay would have done with this camera: redirect to a
|
|
// private address, then answer with HTML.
|
|
const app = mount(t, ({ url }) =>
|
|
url.includes('169.254.169.254')
|
|
? upstreamResponse({
|
|
headers: { 'content-type': 'text/html' },
|
|
body: '<html>metadata</html>',
|
|
})
|
|
: upstreamResponse({
|
|
status: 302,
|
|
headers: { location: 'http://169.254.169.254/latest/meta-data/' },
|
|
body: '',
|
|
}),
|
|
);
|
|
for (const camera of [STILL, STILL_ALIAS]) {
|
|
const res = await app.call(`/media/${camera.id}`);
|
|
assert.equal(res.statusCode, 404, camera.id);
|
|
assert.equal(res.headers['Content-Type'], 'application/json');
|
|
assert.deepEqual(JSON.parse(res.body), {
|
|
error: 'No live media for this camera; use the frame endpoint',
|
|
});
|
|
assert.doesNotMatch(res.body, /metadata/);
|
|
// Being asked on the wrong route is not a camera fault.
|
|
assert.equal(await app.health(camera.id), undefined);
|
|
}
|
|
assert.deepEqual(app.requests, [], 'a still camera reached its upstream');
|
|
});
|
|
|
|
test('an unregistered camera id is refused by /media the same way', async (t) => {
|
|
const app = mount(t, () => {
|
|
throw new Error('an unknown camera must not fetch');
|
|
});
|
|
const res = await app.call('/media/not-a-camera');
|
|
assert.equal(res.statusCode, 404);
|
|
assert.equal(app.requests.length, 0);
|
|
});
|
|
|
|
test('a video camera is still relayed by /media', async (t) => {
|
|
const app = mount(t, () =>
|
|
upstreamResponse({
|
|
headers: { 'content-type': 'video/mp4', 'content-length': '5' },
|
|
body: 'video',
|
|
}),
|
|
);
|
|
const res = await app.call(`/media/${VIDEO.id}`);
|
|
assert.equal(res.statusCode, 200);
|
|
assert.equal(res.headers['Content-Type'], 'video/mp4');
|
|
assert.equal(res.headers['X-CCTV-Source'], 'live-media');
|
|
assert.equal(res.body, 'video');
|
|
assert.deepEqual(
|
|
app.requests.map(({ url }) => url),
|
|
[VIDEO.url],
|
|
);
|
|
assert.equal((await app.health(VIDEO.id)).status, 'ok');
|
|
});
|
|
|
|
test('an MJPEG camera is still relayed by /media', async (t) => {
|
|
const app = mount(t, () =>
|
|
upstreamResponse({
|
|
headers: { 'content-type': 'multipart/x-mixed-replace; boundary=frame' },
|
|
body: '--frame',
|
|
}),
|
|
);
|
|
const res = await app.call(`/media/${MJPEG.id}`);
|
|
assert.equal(res.statusCode, 200);
|
|
assert.match(res.headers['Content-Type'], /^multipart\/x-mixed-replace/);
|
|
assert.equal(res.body, '--frame');
|
|
assert.deepEqual(
|
|
app.requests.map(({ url }) => url),
|
|
[MJPEG.url],
|
|
);
|
|
});
|
|
|
|
test('a still camera is still served through /frame with its bounded fetch', async (t) => {
|
|
const app = mount(t, () =>
|
|
upstreamResponse({
|
|
headers: { 'content-type': 'image/jpeg' },
|
|
body: 'jpeg-bytes',
|
|
}),
|
|
);
|
|
const res = await app.call(`/frame/${STILL.id}`);
|
|
assert.equal(res.statusCode, 200);
|
|
assert.equal(res.headers['Content-Type'], 'image/jpeg');
|
|
assert.equal(res.headers['X-CCTV-Source'], 'upstream-image');
|
|
assert.equal(res.body, 'jpeg-bytes');
|
|
assert.deepEqual(app.requests, [{ url: STILL.url, redirect: 'manual' }]);
|
|
});
|
|
|
|
test('/frame does not follow a still camera off its origin', async (t) => {
|
|
// The protection /media used to bypass, shown on the route that keeps it.
|
|
const app = mount(t, ({ url }) =>
|
|
url === STILL.url
|
|
? upstreamResponse({
|
|
status: 302,
|
|
headers: { location: 'http://169.254.169.254/latest/meta-data/' },
|
|
body: '',
|
|
})
|
|
: upstreamResponse({
|
|
headers: { 'content-type': 'image/jpeg' },
|
|
body: 'private',
|
|
}),
|
|
);
|
|
const res = await app.call(`/frame/${STILL.id}`);
|
|
assert.equal(res.statusCode, 200);
|
|
assert.equal(res.headers['X-CCTV-Source'], 'synthetic');
|
|
assert.doesNotMatch(res.body, /private/);
|
|
assert.deepEqual(
|
|
app.requests.map(({ url }) => url),
|
|
[STILL.url],
|
|
);
|
|
});
|
|
|
|
/** An upstream Response whose body records whether it was cancelled. */
|
|
function trackedUpstream({ status = 200, headers = {}, body = 'payload' }) {
|
|
const state = { cancelled: false };
|
|
const response = new Response(
|
|
new ReadableStream(
|
|
{
|
|
pull(controller) {
|
|
controller.enqueue(new TextEncoder().encode(body));
|
|
controller.close();
|
|
},
|
|
cancel() {
|
|
state.cancelled = true;
|
|
},
|
|
},
|
|
{ highWaterMark: 0 },
|
|
),
|
|
{ status, headers },
|
|
);
|
|
return { response, state };
|
|
}
|
|
|
|
test('/media refuses an upstream type that does not match the feed kind', async (t) => {
|
|
let current;
|
|
const app = mount(t, () => current.response);
|
|
for (const [camera, contentType, body] of [
|
|
[VIDEO, 'text/html', '<!doctype html><p>x</p>'],
|
|
[VIDEO, 'image/svg+xml', '<svg xmlns="http://www.w3.org/2000/svg"/>'],
|
|
[VIDEO, 'application/vnd.apple.mpegurl', '#EXTM3U'],
|
|
[VIDEO, 'video/webm', 'video'],
|
|
[VIDEO, undefined, 'video'],
|
|
[WEBM, 'video/mp4', 'video'],
|
|
[MJPEG, 'multipart/x-mixed-replace', '--frame'],
|
|
[MJPEG, 'multipart/x-mixed-replace; boundary=', '--frame'],
|
|
[MJPEG, 'image/jpeg', 'jpeg'],
|
|
[MJPEG, 'text/html; boundary=frame', '<!doctype html><p>x</p>'],
|
|
]) {
|
|
current = trackedUpstream({
|
|
headers: contentType === undefined ? {} : { 'content-type': contentType },
|
|
body,
|
|
});
|
|
const label = `${camera.id}: ${contentType}`;
|
|
const res = await app.call(`/media/${camera.id}`);
|
|
assert.equal(res.statusCode, 502, label);
|
|
assert.equal(res.headers['Content-Type'], 'application/json', label);
|
|
assert.deepEqual(JSON.parse(res.body), { error: 'Media proxy failed' });
|
|
assert.equal(current.state.cancelled, true, `${label}: upstream cancelled`);
|
|
const health = await app.health(camera.id);
|
|
assert.equal(health.status, 'degraded', label);
|
|
assert.equal(health.message, 'Unexpected media type', label);
|
|
}
|
|
});
|
|
|
|
test('/media relays each feed kind under its canonical type, including a partial response', async (t) => {
|
|
let current;
|
|
const app = mount(t, () => current);
|
|
for (const [camera, upstream, expected] of [
|
|
[VIDEO, { 'content-type': 'Video/MP4; codecs="avc1.42E01E"' }, 'video/mp4'],
|
|
[
|
|
VIDEO,
|
|
{
|
|
'content-type': 'video/mp4',
|
|
'content-range': 'bytes 0-4/100',
|
|
'content-length': '5',
|
|
'accept-ranges': 'bytes',
|
|
},
|
|
'video/mp4',
|
|
],
|
|
[WEBM, { 'content-type': 'video/webm' }, 'video/webm'],
|
|
[
|
|
MJPEG,
|
|
{ 'content-type': 'multipart/x-mixed-replace;boundary="frame"' },
|
|
'multipart/x-mixed-replace; boundary=frame',
|
|
],
|
|
[
|
|
MJPEG,
|
|
{ 'content-type': 'multipart/x-mixed-replace; boundary="a b"' },
|
|
'multipart/x-mixed-replace; boundary="a b"',
|
|
],
|
|
]) {
|
|
const status = upstream['content-range'] ? 206 : 200;
|
|
current = upstreamResponse({ status, headers: upstream, body: 'bytes' });
|
|
const res = await app.call(`/media/${camera.id}`);
|
|
assert.equal(res.statusCode, status, camera.id);
|
|
assert.equal(res.headers['Content-Type'], expected);
|
|
assert.equal(res.body, 'bytes');
|
|
if (status === 206)
|
|
assert.equal(res.headers['Content-Range'], 'bytes 0-4/100');
|
|
assert.equal((await app.health(camera.id)).status, 'ok');
|
|
}
|
|
});
|
|
|
|
test('/media does not follow a live camera off its origin', async (t) => {
|
|
const app = mount(t, ({ url }) =>
|
|
url === VIDEO.url
|
|
? upstreamResponse({
|
|
status: 302,
|
|
headers: { location: 'https://elsewhere.invalid/live.mp4' },
|
|
body: '',
|
|
})
|
|
: upstreamResponse({
|
|
headers: { 'content-type': 'video/mp4' },
|
|
body: 'elsewhere',
|
|
}),
|
|
);
|
|
const res = await app.call(`/media/${VIDEO.id}`);
|
|
assert.equal(res.statusCode, 502);
|
|
assert.doesNotMatch(res.body, /elsewhere/);
|
|
assert.deepEqual(app.requests, [{ url: VIDEO.url, redirect: 'manual' }]);
|
|
});
|
|
|
|
test('every CCTV route refuses cross-site requests and admits the app itself', async (t) => {
|
|
const app = mount(t, ({ url }) =>
|
|
upstreamResponse({
|
|
headers: {
|
|
'content-type': url === VIDEO.url ? 'video/mp4' : 'image/jpeg',
|
|
},
|
|
body: 'bytes',
|
|
}),
|
|
);
|
|
const host = 'localhost:5173';
|
|
const lease = '00000000-0000-4000-8000-000000000000';
|
|
const routes = [
|
|
['GET', '/sources'],
|
|
['GET', '/health'],
|
|
['GET', `/stream/${STILL.id}`],
|
|
['GET', `/frame/${STILL.id}`],
|
|
['GET', `/media/${VIDEO.id}`],
|
|
['GET', `/media/${VIDEO.id}/seg_0.ts?lease=${lease}`],
|
|
['DELETE', `/media/${VIDEO.id}?lease=${lease}`],
|
|
];
|
|
// A catalog refresh would fetch the live packs: a refused request must not
|
|
// start one.
|
|
process.env.CCTV_FORCE_AUSTIN = '1';
|
|
for (const headers of [
|
|
{ host, 'sec-fetch-site': 'cross-site' },
|
|
{ host, 'sec-fetch-site': 'same-site' },
|
|
{ host, origin: 'https://elsewhere.example' },
|
|
{ host, origin: 'null' },
|
|
])
|
|
for (const [method, path] of routes) {
|
|
const res = await app.call(path, headers, method);
|
|
assert.equal(
|
|
res.statusCode,
|
|
403,
|
|
`${method} ${path} ${JSON.stringify(headers)}`,
|
|
);
|
|
}
|
|
assert.deepEqual(app.requests, [], 'a refused request reached an upstream');
|
|
process.env.CCTV_FORCE_AUSTIN = '0';
|
|
for (const headers of [
|
|
{ host, 'sec-fetch-site': 'same-origin' },
|
|
{ host, origin: `http://${host}` },
|
|
{},
|
|
]) {
|
|
const frame = await app.call(`/frame/${STILL.id}`, headers);
|
|
assert.equal(frame.statusCode, 200);
|
|
assert.equal(frame.headers['X-CCTV-Source'], 'upstream-image');
|
|
const media = await app.call(`/media/${VIDEO.id}`, headers);
|
|
assert.equal(media.statusCode, 200);
|
|
assert.equal(media.headers['Content-Type'], 'video/mp4');
|
|
}
|
|
});
|
|
|
|
test('/frame falls back past a non-raster upstream and Street View frame', async (t) => {
|
|
let streetViewType;
|
|
const app = mount(t, ({ url }) =>
|
|
url.startsWith('https://maps.googleapis.com/')
|
|
? trackedUpstream({
|
|
headers:
|
|
streetViewType === undefined
|
|
? {}
|
|
: { 'content-type': streetViewType },
|
|
body: 'street-view',
|
|
}).response
|
|
: upstreamResponse({
|
|
headers: { 'content-type': 'image/svg+xml' },
|
|
body: '<svg xmlns="http://www.w3.org/2000/svg"/>',
|
|
}),
|
|
);
|
|
process.env.GOOGLE_MAPS_SERVER_API_KEY = 'fixture-key';
|
|
for (const type of [
|
|
'image/svg+xml',
|
|
'text/html',
|
|
'application/xml',
|
|
undefined,
|
|
]) {
|
|
streetViewType = type;
|
|
const res = await app.call(`/frame/${STILL.id}`);
|
|
assert.equal(res.statusCode, 200);
|
|
assert.equal(res.headers['X-CCTV-Source'], 'synthetic', String(type));
|
|
assert.doesNotMatch(res.body, /street-view/);
|
|
}
|
|
streetViewType = 'image/JPEG; charset=x';
|
|
const res = await app.call(`/frame/${STILL.id}`);
|
|
assert.equal(res.headers['X-CCTV-Source'], 'streetview');
|
|
assert.equal(res.headers['Content-Type'], 'image/jpeg');
|
|
assert.equal(res.body, 'street-view');
|
|
});
|
|
|
|
test('a forwarded same-origin request reaches every CCTV route but not the Street View fallback', async (t) => {
|
|
const app = mount(t, ({ url }) => {
|
|
if (url.startsWith('https://maps.googleapis.com/'))
|
|
return trackedUpstream({
|
|
headers: { 'content-type': 'image/jpeg' },
|
|
body: 'street-view',
|
|
}).response;
|
|
return url === VIDEO.url
|
|
? upstreamResponse({ headers: { 'content-type': 'video/mp4' } })
|
|
: upstreamResponse({ status: 503, body: '' });
|
|
});
|
|
process.env.GOOGLE_MAPS_SERVER_API_KEY = 'fixture-key';
|
|
const host = 'localhost:5173';
|
|
const streetViewCalls = () =>
|
|
app.requests.filter(({ url }) =>
|
|
url.startsWith('https://maps.googleapis.com/'),
|
|
).length;
|
|
for (const forwarded of [
|
|
{ 'x-forwarded-for': '203.0.113.9' },
|
|
{ via: '1.1 proxy' },
|
|
{ forwarded: 'for=203.0.113.9' },
|
|
{ 'x-real-ip': '203.0.113.9' },
|
|
{ 'x-forwarded-for': '' },
|
|
{ 'x-forwarded-for': ' ' },
|
|
{ 'cf-connecting-ip': '' },
|
|
]) {
|
|
const headers = { host, 'sec-fetch-site': 'same-origin', ...forwarded };
|
|
const label = JSON.stringify(forwarded);
|
|
assert.equal((await app.call('/sources', headers)).statusCode, 200, label);
|
|
const media = await app.call(`/media/${VIDEO.id}`, headers);
|
|
assert.equal(media.statusCode, 200, label);
|
|
assert.equal(media.headers['Content-Type'], 'video/mp4', label);
|
|
const frame = await app.call(`/frame/${STILL.id}`, headers);
|
|
assert.equal(frame.statusCode, 200, label);
|
|
assert.equal(frame.headers['X-CCTV-Source'], 'synthetic', label);
|
|
assert.equal(frame.headers['Content-Type'], 'image/svg+xml', label);
|
|
// Cross-site stays refused whatever the forwarding headers say.
|
|
for (const path of ['/sources', `/frame/${STILL.id}`, `/media/${VIDEO.id}`])
|
|
assert.equal(
|
|
(
|
|
await app.call(path, {
|
|
...forwarded,
|
|
host,
|
|
'sec-fetch-site': 'cross-site',
|
|
})
|
|
).statusCode,
|
|
403,
|
|
`${label} ${path}`,
|
|
);
|
|
}
|
|
assert.equal(streetViewCalls(), 0, 'a forwarded request spent the key');
|
|
const direct = await app.call(`/frame/${STILL.id}`, {
|
|
host,
|
|
'sec-fetch-site': 'same-origin',
|
|
});
|
|
assert.equal(direct.headers['X-CCTV-Source'], 'streetview');
|
|
assert.equal(direct.body, 'street-view');
|
|
assert.equal(streetViewCalls(), 1);
|
|
});
|
|
|
|
test('the Street View fallback frames catalog cameras only, from the catalog position', async (t) => {
|
|
const app = mount(t, ({ url }) =>
|
|
url.startsWith('https://maps.googleapis.com/')
|
|
? trackedUpstream({
|
|
headers: { 'content-type': 'image/jpeg' },
|
|
body: 'street-view',
|
|
}).response
|
|
: upstreamResponse({ status: 503 }),
|
|
);
|
|
process.env.GOOGLE_MAPS_SERVER_API_KEY = 'fixture-key';
|
|
const streetView = () =>
|
|
app.requests.filter(({ url }) =>
|
|
url.startsWith('https://maps.googleapis.com/'),
|
|
);
|
|
|
|
const unknown = await app.call('/frame/not-a-camera?lat=48.85&lon=2.29');
|
|
assert.equal(unknown.headers['X-CCTV-Source'], 'synthetic');
|
|
assert.deepEqual(streetView(), [], 'no Google call for an unknown id');
|
|
|
|
const steered = await app.call(
|
|
`/frame/${STILL.id}?lat=48.85&lon=2.29&heading=90&fov=74&pitch=-17`,
|
|
);
|
|
assert.equal(steered.headers['X-CCTV-Source'], 'streetview');
|
|
const sv = new URL(streetView()[0].url).searchParams;
|
|
assert.equal(sv.get('location'), `${STILL.lat},${STILL.lon}`);
|
|
assert.equal(sv.get('heading'), '90');
|
|
assert.equal(sv.get('fov'), '74');
|
|
assert.equal(sv.get('pitch'), '-17');
|
|
});
|
|
|
|
test('the Street View fallback spends a per-IP Google budget, and only with a key', async (t) => {
|
|
const app = mount(t, ({ url }) =>
|
|
url.startsWith('https://maps.googleapis.com/')
|
|
? trackedUpstream({
|
|
headers: { 'content-type': 'image/jpeg' },
|
|
body: 'street-view',
|
|
}).response
|
|
: upstreamResponse({ status: 503 }),
|
|
);
|
|
// Read when the first keyed fallback builds the limiter, so after mount().
|
|
process.env.GEV_RATELIMIT_GOOGLE_PER_MIN = '2';
|
|
const streetViewCalls = () =>
|
|
app.requests.filter(({ url }) =>
|
|
url.startsWith('https://maps.googleapis.com/'),
|
|
).length;
|
|
const first = '203.0.113.7';
|
|
const frameSource = async (address) =>
|
|
(await app.call(`/frame/${STILL.id}`, {}, 'GET', address)).headers[
|
|
'X-CCTV-Source'
|
|
];
|
|
|
|
// Without a key nothing is spent.
|
|
for (let i = 0; i < 3; i++)
|
|
assert.equal(await frameSource(first), 'synthetic');
|
|
assert.equal(streetViewCalls(), 0);
|
|
|
|
process.env.GOOGLE_MAPS_SERVER_API_KEY = 'fixture-key';
|
|
// Neither an unknown id nor a forwarded request spends the window.
|
|
assert.equal(
|
|
(await app.call('/frame/not-a-camera', {}, 'GET', first)).headers[
|
|
'X-CCTV-Source'
|
|
],
|
|
'synthetic',
|
|
);
|
|
assert.equal(
|
|
(
|
|
await app.call(
|
|
`/frame/${STILL.id}`,
|
|
{ 'x-forwarded-for': '203.0.113.9' },
|
|
'GET',
|
|
first,
|
|
)
|
|
).headers['X-CCTV-Source'],
|
|
'synthetic',
|
|
);
|
|
assert.deepEqual(
|
|
[
|
|
await frameSource(first),
|
|
await frameSource(first),
|
|
await frameSource(first),
|
|
],
|
|
['streetview', 'streetview', 'synthetic'],
|
|
);
|
|
assert.equal(streetViewCalls(), 2, 'no Google call over the budget');
|
|
|
|
// Another address has a budget of its own.
|
|
assert.equal(await frameSource('203.0.113.8'), 'streetview');
|
|
assert.equal(streetViewCalls(), 3);
|
|
|
|
// Addresses within one IPv6 /64 share a budget.
|
|
const v6 = frameSource;
|
|
assert.deepEqual(
|
|
[await v6('2001:db8::1'), await v6('2001:db8::2'), await v6('2001:db8::3')],
|
|
['streetview', 'streetview', 'synthetic'],
|
|
);
|
|
assert.equal(await v6('2001:db8:0:1::1'), 'streetview', 'another /64');
|
|
assert.equal(streetViewCalls(), 6);
|
|
});
|