@open-pencil/cloud 0.16.0 → 0.17.0-beta.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/listen.mjs +236 -117
- package/dist/listen.mjs.map +1 -1
- package/dist/runtime-node.d.mts +2937 -703
- package/dist/runtime-node.d.mts.map +1 -1
- package/dist/server.d.ts +3985 -941
- package/dist/server.d.ts.map +1 -1
- package/dist/server.js +833 -376
- package/dist/server.js.map +1 -1
- package/dist/server.mjs +665 -271
- package/dist/server.mjs.map +1 -1
- package/package.json +4 -2
- package/src/admin/api/routes.ts +44 -33
- package/src/runtime/cloudflare/environment.ts +16 -2
- package/src/runtime/cloudflare/relay/index.ts +128 -0
- package/src/runtime/cloudflare/relay/sockets.ts +112 -0
- package/src/runtime/cloudflare/worker.ts +56 -19
- package/src/runtime/node/bootstrap.ts +9 -4
- package/src/runtime/node/server.ts +40 -8
- package/src/runtime/posthog/errors.ts +48 -0
- package/src/runtime/s3/objects.ts +26 -0
- package/src/runtime/site/server.ts +5 -3
- package/src/server/api/router.ts +3 -2
- package/src/server/api/types.ts +7 -0
- package/src/server/app.ts +4 -0
- package/src/server/cleanup/objects.ts +10 -2
- package/src/server/cleanup/revisions.ts +8 -2
- package/src/server/collaboration/index.ts +3 -0
- package/src/server/collaboration/relay/connection.ts +195 -0
- package/src/server/collaboration/relay/hub.ts +199 -187
- package/src/server/collaboration/relay/index.ts +3 -1
- package/src/server/collaboration/relay/log.ts +76 -0
- package/src/server/collaboration/relay/persistence.ts +147 -22
- package/src/server/collaboration/relay/resume.ts +28 -0
- package/src/server/collaboration/routes.ts +27 -16
- package/src/server/config/deployment.ts +11 -0
- package/src/server/config/schema.ts +24 -2
- package/src/server/db/migrate.ts +3 -1
- package/src/server/db/migrations/028_collaboration_updates.ts +84 -0
- package/src/server/db/tables.ts +18 -4
- package/src/server/documents/routes.ts +106 -80
- package/src/server/documents/versions/routes.ts +36 -25
- package/src/server/documents/versions/service.ts +9 -0
- package/src/server/errors/index.ts +56 -0
- package/src/server/index.ts +11 -0
- package/src/server/internal/routes.ts +3 -8
- package/src/server/objects/types.ts +12 -0
- package/src/server/pictures/routes.ts +4 -2
- package/src/server/rate-limit/index.ts +4 -1
- package/src/server/rate-limit/middleware.ts +99 -11
- package/src/server/sharing/document-routes.ts +30 -22
- package/src/server/sharing/routes.ts +122 -83
- package/src/server/validation.ts +58 -2
- package/src/server/workspaces/routes.ts +63 -45
- package/src/runtime/cloudflare/relay.ts +0 -136
|
@@ -1,4 +1,5 @@
|
|
|
1
1
|
import { defaultRelayURL } from '#cloud/contract'
|
|
2
|
+
import { createPostHogErrorReporter } from '#cloud/runtime/posthog/errors'
|
|
2
3
|
import { createS3ObjectStore } from '#cloud/runtime/s3/objects'
|
|
3
4
|
import { createCloudServer, type SiteFiles } from '#cloud/runtime/site/server'
|
|
4
5
|
import {
|
|
@@ -11,11 +12,15 @@ import {
|
|
|
11
12
|
createCleanupServices,
|
|
12
13
|
createConfiguredCloudPolicy,
|
|
13
14
|
relayDocumentLookups,
|
|
15
|
+
reportCloudError,
|
|
14
16
|
startCleanupWorker,
|
|
15
|
-
startTransactionalEmailWorker
|
|
17
|
+
startTransactionalEmailWorker,
|
|
18
|
+
type CloudErrorReporter,
|
|
19
|
+
type CloudServerConfig
|
|
16
20
|
} from '#cloud/server'
|
|
17
21
|
|
|
18
|
-
import {
|
|
22
|
+
import { migratedNodeCloudDatabase } from './bootstrap'
|
|
23
|
+
import { loadNodeCloudServerConfig } from './config'
|
|
19
24
|
import { createNodeTransactionalEmailRuntime } from './email/runtime'
|
|
20
25
|
import { listen } from './listen'
|
|
21
26
|
import { attachCollaborationRelay } from './relay'
|
|
@@ -40,9 +45,30 @@ function siteFiles(
|
|
|
40
45
|
return undefined
|
|
41
46
|
}
|
|
42
47
|
|
|
48
|
+
/**
|
|
49
|
+
* Starts the server. Once the config parses, a startup that fails, such as a migration, a signing
|
|
50
|
+
* key, or a port that cannot be bound, is reported before it is thrown; a config that does not
|
|
51
|
+
* parse has no error tracking to report to.
|
|
52
|
+
*/
|
|
43
53
|
export async function startNodeCloudServer(options: NodeCloudServerOptions = {}) {
|
|
44
54
|
const environment = options.environment ?? process.env
|
|
45
|
-
const
|
|
55
|
+
const config = await loadNodeCloudServerConfig(environment)
|
|
56
|
+
const reportError = createPostHogErrorReporter(config, 'node')
|
|
57
|
+
try {
|
|
58
|
+
return await startConfiguredServer(config, environment, options, reportError)
|
|
59
|
+
} catch (error) {
|
|
60
|
+
await reportCloudError(reportError, 'Starting the server failed:', error, { source: 'setup' })
|
|
61
|
+
throw error
|
|
62
|
+
}
|
|
63
|
+
}
|
|
64
|
+
|
|
65
|
+
async function startConfiguredServer(
|
|
66
|
+
config: CloudServerConfig,
|
|
67
|
+
environment: Readonly<Record<string, string | undefined>>,
|
|
68
|
+
options: NodeCloudServerOptions,
|
|
69
|
+
reportError: CloudErrorReporter | undefined
|
|
70
|
+
) {
|
|
71
|
+
const { database } = await migratedNodeCloudDatabase(config)
|
|
46
72
|
// Before any worker starts, so a key that cannot sign leaves nothing running.
|
|
47
73
|
const aiSigningKey = await loadAISigningKey(config).catch(async (error: unknown) => {
|
|
48
74
|
await database.destroy()
|
|
@@ -60,14 +86,17 @@ export async function startNodeCloudServer(options: NodeCloudServerOptions = {})
|
|
|
60
86
|
? startCleanupWorker(createCleanupServices(config, database, objects, policy), {
|
|
61
87
|
...cleanupPassOptions(config),
|
|
62
88
|
intervalMs: config.cleanupIntervalMs,
|
|
63
|
-
onError: (error) =>
|
|
89
|
+
onError: (error) =>
|
|
90
|
+
void reportCloudError(reportError, 'Cleanup worker failed:', error, { source: 'cleanup' })
|
|
64
91
|
})
|
|
65
92
|
: undefined
|
|
66
93
|
const relay = createCollaborationRelay({
|
|
67
94
|
authSecret: config.authSecret,
|
|
68
|
-
store: createCollaborationStateStore(database),
|
|
95
|
+
store: createCollaborationStateStore(database, objects),
|
|
69
96
|
maximumMessageBytes: config.technicalLimits.maximumCollaborationMessageBytes,
|
|
70
97
|
maximumConnectionsPerRoom: config.technicalLimits.maximumConnectionsPerRoom,
|
|
98
|
+
onError: (message, error) =>
|
|
99
|
+
void reportCloudError(reportError, message, error, { source: 'relay' }),
|
|
71
100
|
...relayDocumentLookups(database, policy, config.deployment)
|
|
72
101
|
})
|
|
73
102
|
const app = createCloudApp({
|
|
@@ -81,7 +110,8 @@ export async function startNodeCloudServer(options: NodeCloudServerOptions = {})
|
|
|
81
110
|
aiSigningKey,
|
|
82
111
|
relayURL: config.relayURL ?? defaultRelayURL(config.publicURL),
|
|
83
112
|
onDocumentRestored: (documentId) => relay.startOver(documentId),
|
|
84
|
-
onDocumentVersionsChanged: (documentId) => relay.announceVersions(documentId)
|
|
113
|
+
onDocumentVersionsChanged: (documentId) => relay.announceVersions(documentId),
|
|
114
|
+
reportError
|
|
85
115
|
})
|
|
86
116
|
const emailWorker = emailTransport
|
|
87
117
|
? startTransactionalEmailWorker(email, {
|
|
@@ -89,12 +119,14 @@ export async function startNodeCloudServer(options: NodeCloudServerOptions = {})
|
|
|
89
119
|
intervalMs: config.emailIntervalMs,
|
|
90
120
|
leaseDurationMs: config.emailLeaseDurationMs,
|
|
91
121
|
maximumAttempts: config.emailMaximumAttempts,
|
|
92
|
-
onError: (error) =>
|
|
122
|
+
onError: (error) =>
|
|
123
|
+
void reportCloudError(reportError, 'Email worker failed:', error, { source: 'email' })
|
|
93
124
|
})
|
|
94
125
|
: undefined
|
|
95
126
|
const cloudServer = createCloudServer(app, {
|
|
96
127
|
site: siteFiles(environment),
|
|
97
|
-
indexingPolicy: config.indexingPolicy
|
|
128
|
+
indexingPolicy: config.indexingPolicy,
|
|
129
|
+
reportError
|
|
98
130
|
})
|
|
99
131
|
const server = await listen(
|
|
100
132
|
async (request) => cloudServer.fetch(request),
|
|
@@ -0,0 +1,48 @@
|
|
|
1
|
+
import type { CloudServerConfig } from '#cloud/server'
|
|
2
|
+
import type { CloudErrorReporter } from '#cloud/server/errors'
|
|
3
|
+
import { PostHog, type PostHogOptions } from 'posthog-node'
|
|
4
|
+
|
|
5
|
+
/** Which runtime serves the deployment, as its error reports name it. */
|
|
6
|
+
export type CloudRuntimeName = 'node' | 'cloudflare'
|
|
7
|
+
|
|
8
|
+
/**
|
|
9
|
+
* Reports server errors to the PostHog project the deployment's `[error_tracking]` names, or
|
|
10
|
+
* returns nothing when it names none. Each error is sent as it is caught, as a `$exception` with
|
|
11
|
+
* no person profile: reports carry the runtime, the deployment, and where the error was caught,
|
|
12
|
+
* never who made the request or what it carried.
|
|
13
|
+
*/
|
|
14
|
+
export function createPostHogErrorReporter(
|
|
15
|
+
config: CloudServerConfig,
|
|
16
|
+
runtime: CloudRuntimeName,
|
|
17
|
+
options: Pick<PostHogOptions, 'fetch'> = {}
|
|
18
|
+
): CloudErrorReporter | undefined {
|
|
19
|
+
const tracking = config.errorTracking
|
|
20
|
+
if (!tracking) return undefined
|
|
21
|
+
const client = new PostHog(tracking.projectAPIKey, {
|
|
22
|
+
host: tracking.host,
|
|
23
|
+
disableGeoip: true,
|
|
24
|
+
...options
|
|
25
|
+
})
|
|
26
|
+
// The SDK resolves a capture that PostHog refused and emits the refusal instead.
|
|
27
|
+
client.on('error', (failure: unknown) => {
|
|
28
|
+
console.error('[Cloud] PostHog refused an error report:', failure)
|
|
29
|
+
})
|
|
30
|
+
const deployment = {
|
|
31
|
+
cloud_runtime: runtime,
|
|
32
|
+
cloud_deployment: config.deployment,
|
|
33
|
+
cloud_host: new URL(config.publicURL).host
|
|
34
|
+
}
|
|
35
|
+
return async (error, context) => {
|
|
36
|
+
try {
|
|
37
|
+
// Undefined request fields are left out of the event's JSON.
|
|
38
|
+
await client.captureExceptionImmediate(error, undefined, {
|
|
39
|
+
...deployment,
|
|
40
|
+
cloud_source: context.source,
|
|
41
|
+
http_method: context.method,
|
|
42
|
+
http_route: context.route
|
|
43
|
+
})
|
|
44
|
+
} catch (failure) {
|
|
45
|
+
console.error('[Cloud] Reporting an error failed:', failure)
|
|
46
|
+
}
|
|
47
|
+
}
|
|
48
|
+
}
|
|
@@ -239,6 +239,32 @@ export function createS3ObjectStore(config: CloudServerConfig): ObjectStore {
|
|
|
239
239
|
|
|
240
240
|
async delete(key) {
|
|
241
241
|
await client.send(new DeleteObjectCommand({ Bucket: config.s3Bucket, Key: key }))
|
|
242
|
+
},
|
|
243
|
+
|
|
244
|
+
async write(input) {
|
|
245
|
+
await client.send(
|
|
246
|
+
new PutObjectCommand({
|
|
247
|
+
Bucket: config.s3Bucket,
|
|
248
|
+
Key: input.key,
|
|
249
|
+
Body: input.bytes,
|
|
250
|
+
ContentType: input.contentType,
|
|
251
|
+
ChecksumSHA256: nativeSHA256 ? input.checksum : undefined,
|
|
252
|
+
Metadata: { [CHECKSUM_METADATA_KEY]: input.checksum },
|
|
253
|
+
...encryption(config)
|
|
254
|
+
})
|
|
255
|
+
)
|
|
256
|
+
},
|
|
257
|
+
|
|
258
|
+
async read(key) {
|
|
259
|
+
try {
|
|
260
|
+
const object = await client.send(
|
|
261
|
+
new GetObjectCommand({ Bucket: config.s3Bucket, Key: key })
|
|
262
|
+
)
|
|
263
|
+
return object.Body ? await object.Body.transformToByteArray() : null
|
|
264
|
+
} catch (error) {
|
|
265
|
+
if (isNotFoundError(error)) return null
|
|
266
|
+
throw error
|
|
267
|
+
}
|
|
242
268
|
}
|
|
243
269
|
}
|
|
244
270
|
}
|
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
import { CLOUD_PORTAL_PAGE_ROOTS } from '#cloud/contract'
|
|
2
|
-
import { withIndexingPolicy } from '#cloud/server'
|
|
2
|
+
import { cloudErrorHandler, withIndexingPolicy, type CloudErrorReporter } from '#cloud/server'
|
|
3
3
|
import { Hono } from 'hono'
|
|
4
4
|
|
|
5
5
|
/** A file of the Cloud site (`bun run build:cloud`): the editor and the portal. */
|
|
@@ -29,6 +29,8 @@ export type CloudServerOptions = {
|
|
|
29
29
|
/** The built site; without it, the server answers only its API. */
|
|
30
30
|
site?: SiteFiles
|
|
31
31
|
indexingPolicy: 'allow' | 'deny'
|
|
32
|
+
/** Reports errors reading the site's files, when the deployment configures error tracking. */
|
|
33
|
+
reportError?: CloudErrorReporter
|
|
32
34
|
}
|
|
33
35
|
|
|
34
36
|
function cacheControl(path: string): string {
|
|
@@ -43,9 +45,9 @@ function cacheControl(path: string): string {
|
|
|
43
45
|
*/
|
|
44
46
|
export function createCloudServer(
|
|
45
47
|
api: { fetch(request: Request): Response | Promise<Response> },
|
|
46
|
-
{ site, indexingPolicy }: CloudServerOptions
|
|
48
|
+
{ site, indexingPolicy, reportError }: CloudServerOptions
|
|
47
49
|
) {
|
|
48
|
-
const server = new Hono()
|
|
50
|
+
const server = new Hono().onError(cloudErrorHandler(reportError))
|
|
49
51
|
server.use(async (c, next) => {
|
|
50
52
|
await next()
|
|
51
53
|
c.res = withIndexingPolicy(c.res, c.req.path, indexingPolicy)
|
package/src/server/api/router.ts
CHANGED
|
@@ -20,6 +20,7 @@ import {
|
|
|
20
20
|
createPublicDocumentRoutes,
|
|
21
21
|
createPublicSharingRoutes
|
|
22
22
|
} from '#cloud/server/sharing'
|
|
23
|
+
import { workspaceParams } from '#cloud/server/validation'
|
|
23
24
|
import type { WorkspaceMemberService, WorkspaceService } from '#cloud/server/workspaces'
|
|
24
25
|
import { createWorkspaceRoutes } from '#cloud/server/workspaces'
|
|
25
26
|
import { Hono } from 'hono'
|
|
@@ -53,13 +54,13 @@ export function createPublicCloudAPIRouter(services: CloudAPIServices) {
|
|
|
53
54
|
export function createCloudAPIRouter(services: CloudAPIServices) {
|
|
54
55
|
return new Hono<CloudAPIEnvironment>()
|
|
55
56
|
.route('/public', createPublicCloudAPIRouter(services))
|
|
56
|
-
.get('/workspaces/:workspaceId/entitlements', async (context) => {
|
|
57
|
+
.get('/workspaces/:workspaceId/entitlements', workspaceParams, async (context) => {
|
|
57
58
|
if (!services.entitlements)
|
|
58
59
|
return context.json({ error: { code: 'not_found' as const } }, 404)
|
|
59
60
|
return context.json({
|
|
60
61
|
entitlements: await services.entitlements.workspace(
|
|
61
62
|
context.get('actor').userId,
|
|
62
|
-
context.req.
|
|
63
|
+
context.req.valid('param').workspaceId
|
|
63
64
|
)
|
|
64
65
|
})
|
|
65
66
|
})
|
package/src/server/api/types.ts
CHANGED
|
@@ -1,7 +1,14 @@
|
|
|
1
1
|
import type { CloudActor } from '#cloud/server/auth'
|
|
2
2
|
|
|
3
|
+
/** What a rate limiter records on the request about the budget it just counted. */
|
|
4
|
+
export type RateLimitUse = { limit: number; remaining: number; resetTime?: Date }
|
|
5
|
+
|
|
3
6
|
export type CloudAPIEnvironment = {
|
|
4
7
|
Variables: {
|
|
5
8
|
actor: CloudActor
|
|
9
|
+
/** Set by `hono-rate-limiter` for the last budget it counted. */
|
|
10
|
+
rateLimit?: RateLimitUse
|
|
11
|
+
/** A resource budget's use, kept before the actor-wide budget records its own. */
|
|
12
|
+
resourceRateLimit?: RateLimitUse
|
|
6
13
|
}
|
|
7
14
|
}
|
package/src/server/app.ts
CHANGED
|
@@ -39,6 +39,7 @@ import type { CloudDatabase } from '#cloud/server/db'
|
|
|
39
39
|
import { createDocumentService } from '#cloud/server/documents'
|
|
40
40
|
import { createDocumentVersionService } from '#cloud/server/documents/versions'
|
|
41
41
|
import type { TransactionalEmailService } from '#cloud/server/email'
|
|
42
|
+
import { cloudErrorHandler, type CloudErrorReporter } from '#cloud/server/errors'
|
|
42
43
|
import { createInternalRoutes, createInternalService } from '#cloud/server/internal'
|
|
43
44
|
import type { InvitationDelivery, InvitationOutbox } from '#cloud/server/invitations'
|
|
44
45
|
import type { ObjectStore } from '#cloud/server/objects'
|
|
@@ -87,6 +88,8 @@ export type CloudServices = {
|
|
|
87
88
|
onDocumentRestored?: (documentId: string) => void
|
|
88
89
|
/** Tells a document's live rooms its version history changed, on the relay this runtime runs. */
|
|
89
90
|
onDocumentVersionsChanged?: (documentId: string) => void
|
|
91
|
+
/** Reports errors no route handled, when the deployment configures error tracking. */
|
|
92
|
+
reportError?: CloudErrorReporter
|
|
90
93
|
}
|
|
91
94
|
|
|
92
95
|
type CloudEnvironment = CloudAPIEnvironment
|
|
@@ -310,6 +313,7 @@ export function createCloudApp(services: CloudServices) {
|
|
|
310
313
|
: new Hono()
|
|
311
314
|
|
|
312
315
|
return new Hono<CloudEnvironment>()
|
|
316
|
+
.onError(cloudErrorHandler(services.reportError))
|
|
313
317
|
.use(CLOUD_DISCOVERY_PATH, cloudCORS)
|
|
314
318
|
.use('/api/*', cloudCORS)
|
|
315
319
|
.use('*', async (context, next) => {
|
|
@@ -2,8 +2,8 @@ import type { CloudDatabase } from '#cloud/server/db'
|
|
|
2
2
|
import type { ExpressionBuilder } from 'kysely'
|
|
3
3
|
|
|
4
4
|
/**
|
|
5
|
-
* No revision refers to the stored file any more,
|
|
6
|
-
* can leave the object store.
|
|
5
|
+
* No revision refers to the stored file any more, no workspace keeps it as an image, and no
|
|
6
|
+
* collaboration room keeps it as its snapshot, so it can leave the object store.
|
|
7
7
|
*/
|
|
8
8
|
export function unreferencedObject(expression: ExpressionBuilder<CloudDatabase, 'storageObject'>) {
|
|
9
9
|
return expression.and([
|
|
@@ -22,6 +22,14 @@ export function unreferencedObject(expression: ExpressionBuilder<CloudDatabase,
|
|
|
22
22
|
.select('workspaceImage.checksum')
|
|
23
23
|
.whereRef('workspaceImage.storageObjectId', '=', 'storageObject.id')
|
|
24
24
|
)
|
|
25
|
+
),
|
|
26
|
+
expression.not(
|
|
27
|
+
expression.exists(
|
|
28
|
+
expression
|
|
29
|
+
.selectFrom('documentRoomSnapshot')
|
|
30
|
+
.select('documentRoomSnapshot.documentId')
|
|
31
|
+
.whereRef('documentRoomSnapshot.snapshotObjectId', '=', 'storageObject.id')
|
|
32
|
+
)
|
|
25
33
|
)
|
|
26
34
|
])
|
|
27
35
|
}
|
|
@@ -11,6 +11,11 @@ import { unreferencedObject } from './objects'
|
|
|
11
11
|
|
|
12
12
|
/** How long a save between versions is kept before compaction may delete it. */
|
|
13
13
|
export const REVISION_COMPACTION_GRACE_MS = 24 * 60 * 60_000
|
|
14
|
+
/**
|
|
15
|
+
* How long a stored file nothing refers to is left alone: a collaboration room records its next
|
|
16
|
+
* snapshot's file before writing it and points the room at it moments later.
|
|
17
|
+
*/
|
|
18
|
+
export const OBJECT_SWEEP_GRACE_MS = 15 * 60_000
|
|
14
19
|
|
|
15
20
|
export type RevisionCompactionOptions = {
|
|
16
21
|
batchSize: number
|
|
@@ -161,9 +166,10 @@ export function createRevisionCompactionService(
|
|
|
161
166
|
}
|
|
162
167
|
|
|
163
168
|
/** Deletes freed files from the object store, then their rows; a failure stays for next time. */
|
|
164
|
-
async function sweepObjects(batchSize: number, result: RevisionCompactionResult) {
|
|
169
|
+
async function sweepObjects(now: Date, batchSize: number, result: RevisionCompactionResult) {
|
|
165
170
|
const freed = await unreferencedObjects(database)
|
|
166
171
|
.select(['id', 'objectKey'])
|
|
172
|
+
.where('createdAt', '<', new Date(now.getTime() - OBJECT_SWEEP_GRACE_MS))
|
|
167
173
|
.limit(batchSize)
|
|
168
174
|
.execute()
|
|
169
175
|
for (const object of freed) {
|
|
@@ -225,7 +231,7 @@ export function createRevisionCompactionService(
|
|
|
225
231
|
} catch {
|
|
226
232
|
result.failed++
|
|
227
233
|
}
|
|
228
|
-
await sweepObjects(input.batchSize, result)
|
|
234
|
+
await sweepObjects(now, input.batchSize, result)
|
|
229
235
|
return result
|
|
230
236
|
}
|
|
231
237
|
}
|
|
@@ -0,0 +1,195 @@
|
|
|
1
|
+
import {
|
|
2
|
+
createRelayClientAssembler,
|
|
3
|
+
decodeRelayClientFrame,
|
|
4
|
+
MAX_COLLAB_MESSAGE_BYTES,
|
|
5
|
+
RELAY_CLOSE,
|
|
6
|
+
type RelayClientFrame
|
|
7
|
+
} from '#cloud/contract'
|
|
8
|
+
|
|
9
|
+
import { authorizeRelayTicket, principalKey, type RelayAuthorization } from './authorize'
|
|
10
|
+
import type { RelayPeerState } from './resume'
|
|
11
|
+
|
|
12
|
+
/** One client's socket, as a runtime adapter hands it to the relay. */
|
|
13
|
+
export type RelaySocket = {
|
|
14
|
+
send(data: Uint8Array): void
|
|
15
|
+
close(code: number, reason: string): void
|
|
16
|
+
/**
|
|
17
|
+
* Keeps the peer's state with the socket, for a runtime that sets the relay aside while sockets
|
|
18
|
+
* stay open and resumes their peers with `resume` when it wakes.
|
|
19
|
+
*/
|
|
20
|
+
remember?(state: RelayPeerState): void
|
|
21
|
+
}
|
|
22
|
+
|
|
23
|
+
/** What the adapter reports back about that socket. */
|
|
24
|
+
export type RelayConnection = {
|
|
25
|
+
receive(data: Uint8Array): void
|
|
26
|
+
closed(): void
|
|
27
|
+
}
|
|
28
|
+
|
|
29
|
+
/** A socket admitted to a room, as the person and permission its ticket names. */
|
|
30
|
+
export type RelayPeer = {
|
|
31
|
+
id: string
|
|
32
|
+
socket: RelaySocket
|
|
33
|
+
authorization: RelayAuthorization
|
|
34
|
+
presenceClients: Set<number>
|
|
35
|
+
}
|
|
36
|
+
|
|
37
|
+
/** A room message from an admitted peer. */
|
|
38
|
+
export type RelayRoomFrame = Extract<RelayClientFrame, { type: 'message' }>
|
|
39
|
+
|
|
40
|
+
/** What a connection asks of the relay it belongs to. */
|
|
41
|
+
export type ConnectionRelay = {
|
|
42
|
+
authSecret: string
|
|
43
|
+
/** The one document the relay serves, when it serves one. */
|
|
44
|
+
documentId?: string
|
|
45
|
+
maximumMessageBytes: number
|
|
46
|
+
authTimeoutMs: number
|
|
47
|
+
/** Admits a newcomer whose ticket verified, or turns it away and answers null. */
|
|
48
|
+
admit(socket: RelaySocket, authorization: RelayAuthorization): Promise<RelayPeer | null>
|
|
49
|
+
/** Takes a refreshed ticket for a peer already in its room. */
|
|
50
|
+
refreshed(peer: RelayPeer): void
|
|
51
|
+
/** Handles a peer's room message; a promise while it waits for the room's document. */
|
|
52
|
+
deliver(peer: RelayPeer, frame: RelayRoomFrame): Promise<void> | undefined
|
|
53
|
+
depart(peer: RelayPeer): void
|
|
54
|
+
report(message: string, error: unknown): void
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
/**
|
|
58
|
+
* A socket's connection: a new one, which presents a ticket before it joins, or one resumed with
|
|
59
|
+
* the peer it already is. It joins fragmented frames, holds what arrives while a ticket is checked
|
|
60
|
+
* or the room's document loads, and refreshes tickets.
|
|
61
|
+
*/
|
|
62
|
+
export function openRelayConnection(
|
|
63
|
+
socket: RelaySocket,
|
|
64
|
+
resumed: RelayPeer | null,
|
|
65
|
+
relay: ConnectionRelay
|
|
66
|
+
): RelayConnection {
|
|
67
|
+
let peer: RelayPeer | null = resumed
|
|
68
|
+
/** Read through an object, since it changes across awaits and between messages. */
|
|
69
|
+
const state = { closed: false, busy: false }
|
|
70
|
+
const isClosed = () => state.closed
|
|
71
|
+
const queued: Uint8Array[] = []
|
|
72
|
+
let queuedBytes = 0
|
|
73
|
+
// Only an editor's writes can be large: a viewer's frames, and a peer's before it is
|
|
74
|
+
// admitted, fit in one message, so nobody else can make the relay hold more.
|
|
75
|
+
const assembler = createRelayClientAssembler(() =>
|
|
76
|
+
peer?.authorization.permission === 'edit' ? MAX_COLLAB_MESSAGE_BYTES : relay.maximumMessageBytes
|
|
77
|
+
)
|
|
78
|
+
const authTimer = resumed
|
|
79
|
+
? undefined
|
|
80
|
+
: setTimeout(
|
|
81
|
+
() => socket.close(RELAY_CLOSE.unauthorized, 'Expected a collaboration ticket'),
|
|
82
|
+
relay.authTimeoutMs
|
|
83
|
+
)
|
|
84
|
+
|
|
85
|
+
async function authenticate(token: string) {
|
|
86
|
+
let authorization: RelayAuthorization
|
|
87
|
+
try {
|
|
88
|
+
authorization = await authorizeRelayTicket(token, relay.authSecret)
|
|
89
|
+
} catch {
|
|
90
|
+
socket.close(RELAY_CLOSE.unauthorized, 'Invalid collaboration ticket')
|
|
91
|
+
return
|
|
92
|
+
}
|
|
93
|
+
if (relay.documentId !== undefined && authorization.documentId !== relay.documentId) {
|
|
94
|
+
socket.close(RELAY_CLOSE.unauthorized, 'Ticket is for a different document')
|
|
95
|
+
return
|
|
96
|
+
}
|
|
97
|
+
if (state.closed) return
|
|
98
|
+
if (peer) {
|
|
99
|
+
// A refreshed ticket keeps the peer in its room as the same person; a lowered
|
|
100
|
+
// permission applies from now on.
|
|
101
|
+
const current = peer.authorization
|
|
102
|
+
if (
|
|
103
|
+
authorization.roomId !== current.roomId ||
|
|
104
|
+
principalKey(authorization.principal) !== principalKey(current.principal)
|
|
105
|
+
) {
|
|
106
|
+
socket.close(RELAY_CLOSE.unauthorized, 'Ticket is for a different room or person')
|
|
107
|
+
return
|
|
108
|
+
}
|
|
109
|
+
peer.authorization = authorization
|
|
110
|
+
relay.refreshed(peer)
|
|
111
|
+
return
|
|
112
|
+
}
|
|
113
|
+
clearTimeout(authTimer)
|
|
114
|
+
const admitted = await relay.admit(socket, authorization)
|
|
115
|
+
// The socket may have closed while the room loaded.
|
|
116
|
+
if (admitted && isClosed()) relay.depart(admitted)
|
|
117
|
+
else peer = admitted
|
|
118
|
+
}
|
|
119
|
+
|
|
120
|
+
function process(data: Uint8Array) {
|
|
121
|
+
if (data.byteLength > relay.maximumMessageBytes) {
|
|
122
|
+
socket.close(RELAY_CLOSE.messageTooLarge, 'Collaboration message is too large')
|
|
123
|
+
return
|
|
124
|
+
}
|
|
125
|
+
const assembled = assembler.push(data)
|
|
126
|
+
if (assembled.type === 'partial') return
|
|
127
|
+
if (assembled.type === 'too-large') {
|
|
128
|
+
socket.close(RELAY_CLOSE.messageTooLarge, 'Collaboration message is too large')
|
|
129
|
+
return
|
|
130
|
+
}
|
|
131
|
+
const frame = assembled.type === 'frame' ? decodeRelayClientFrame(assembled.data) : null
|
|
132
|
+
if (!frame) {
|
|
133
|
+
socket.close(RELAY_CLOSE.protocol, 'Malformed collaboration frame')
|
|
134
|
+
return
|
|
135
|
+
}
|
|
136
|
+
if (frame.type === 'auth') {
|
|
137
|
+
state.busy = true
|
|
138
|
+
void authenticate(frame.token)
|
|
139
|
+
.catch((error: unknown) => {
|
|
140
|
+
relay.report('Admitting a collaboration peer failed:', error)
|
|
141
|
+
socket.close(RELAY_CLOSE.protocol, 'Could not open the collaboration room')
|
|
142
|
+
})
|
|
143
|
+
.finally(() => {
|
|
144
|
+
state.busy = false
|
|
145
|
+
flush()
|
|
146
|
+
})
|
|
147
|
+
return
|
|
148
|
+
}
|
|
149
|
+
if (!peer) {
|
|
150
|
+
socket.close(RELAY_CLOSE.unauthorized, 'Expected a collaboration ticket')
|
|
151
|
+
return
|
|
152
|
+
}
|
|
153
|
+
const delivered = relay.deliver(peer, frame)
|
|
154
|
+
if (!delivered) return
|
|
155
|
+
// The room's document is loading; this peer's later messages wait for it.
|
|
156
|
+
state.busy = true
|
|
157
|
+
void delivered.finally(() => {
|
|
158
|
+
state.busy = false
|
|
159
|
+
flush()
|
|
160
|
+
})
|
|
161
|
+
}
|
|
162
|
+
|
|
163
|
+
function flush() {
|
|
164
|
+
while (!state.busy && !state.closed && queued.length > 0) {
|
|
165
|
+
const next = queued.shift()
|
|
166
|
+
if (!next) continue
|
|
167
|
+
queuedBytes -= next.byteLength
|
|
168
|
+
process(next)
|
|
169
|
+
}
|
|
170
|
+
}
|
|
171
|
+
|
|
172
|
+
return {
|
|
173
|
+
receive(data) {
|
|
174
|
+
if (state.closed) return
|
|
175
|
+
queuedBytes += data.byteLength
|
|
176
|
+
// Before admission a peer has sent its ticket and has nothing else to say, so what
|
|
177
|
+
// waits for the room to open is held to one message's worth.
|
|
178
|
+
if (!peer && queuedBytes > relay.maximumMessageBytes) {
|
|
179
|
+
queued.length = 0
|
|
180
|
+
queuedBytes = 0
|
|
181
|
+
socket.close(RELAY_CLOSE.messageTooLarge, 'Too much sent before joining the room')
|
|
182
|
+
return
|
|
183
|
+
}
|
|
184
|
+
queued.push(data)
|
|
185
|
+
flush()
|
|
186
|
+
},
|
|
187
|
+
closed() {
|
|
188
|
+
state.closed = true
|
|
189
|
+
queued.length = 0
|
|
190
|
+
queuedBytes = 0
|
|
191
|
+
clearTimeout(authTimer)
|
|
192
|
+
if (peer) relay.depart(peer)
|
|
193
|
+
}
|
|
194
|
+
}
|
|
195
|
+
}
|