Weishen/Hydro
2
0 Fork 0
mirror of https://gitcode.com/gh_mirrors/hy/Hydro.git synced 2026-10-20 01:38:19 +08:00
Code Issues Packages Projects Releases Wiki Activity

core: add server-loader (#816)

Browse Source
This commit is contained in:
undefined authored and GitHub committed 2024-06-03 19:29:41 +08:00
1 parent 3302480348
commit 97720efb65
57 files changed
+1328 -1131
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

packages/hydrooj/package.json
+9 -15
View File
@@ -12,17 +12,18 @@
},
"preferUnplugged": true,
"dependencies": {
"@aws-sdk/client-s3": "3.572.0",
"@aws-sdk/lib-storage": "3.572.0",
"@aws-sdk/s3-presigned-post": "3.572.0",
"@aws-sdk/s3-request-presigner": "3.572.0",
"@graphql-tools/schema": "^10.0.3",
"@hydrooj/utils": "workspace:*",
"@aws-sdk/client-s3": "3.583.0",
"@aws-sdk/lib-storage": "3.583.0",
"@aws-sdk/s3-presigned-post": "3.583.0",
"@aws-sdk/s3-request-presigner": "3.583.0",
"@graphql-tools/schema": "^10.0.4",
"@hydrooj/framework": "workspace:^",
"@hydrooj/utils": "workspace:^",
"@simplewebauthn/server": "7.4.0",
"@undefined-moe/require-resolve-hook": "^1.1.0",
"adm-zip": "0.5.5",
"cac": "^6.7.14",
"cordis": "3.13.3",
"cordis": "3.16.0",
"detect-browser": "^5.3.0",
"emoji-regex": "^10.3.0",
"emojis-list": "2.1.0",
@@ -30,11 +31,7 @@
"graphql": "^16.8.1",
"graphql-scalars": "^1.23.0",
"js-yaml": "^4.1.0",
"koa": "^2.15.3",
"koa-body": "^6.0.1",
"koa-compress": "^5.1.1",
"koa-proxies": "^0.12.4",
"koa-router": "^12.0.1",
"koa-static-cache": "^5.1.4",
"lodash": "^4.17.21",
"lru-cache": "^10.2.2",
@@ -61,11 +58,8 @@
"@types/adm-zip": "^0.4.34",
"@types/fs-extra": "^11.0.4",
"@types/js-yaml": "^4.0.9",
"@types/koa": "^2.15.0",
"@types/koa-compress": "^4.0.6",
"@types/koa-router": "^7.4.8",
"@types/koa-static-cache": "^5.1.4",
"@types/lodash": "^4.17.1",
"@types/lodash": "^4.17.4",
"@types/mime-types": "^2.1.4",
"@types/mongodb-uri": "^0.9.4",
"@types/nodemailer": "^6.4.15",
packages/hydrooj/src/context.ts
+7 -16
View File
@@ -1,12 +1,14 @@
import * as cordis from 'cordis';
import Schema from 'schemastery';
import type { ServerEvents, WebService } from '@hydrooj/framework';
import type { DomainDoc, GeoIP, ModuleInterfaces } from './interface';
import { inject } from './lib/ui';
import { Loader } from './loader';
import { EventMap } from './service/bus';
import type { EventMap } from './service/bus';
import type { CheckService } from './service/check';
import type { ConnectionHandler, Handler } from './service/server';
export interface Events<C extends Context = Context> extends cordis.Events<C>, EventMap { }
export interface Events<C extends Context = Context> extends cordis.Events<C>, EventMap, ServerEvents<Handler, ConnectionHandler> { }
function addScript<K>(name: string, description: string, validate: Schema<K>, run: (args: K, report: any) => boolean | Promise<boolean>) {
if (global.Hydro.script[name]) throw new Error(`duplicate script ${name} registered.`);
@@ -26,12 +28,10 @@ export type MainScope = cordis.MainScope<Context>;
export type { Disposable, ScopeStatus, Plugin } from 'cordis';
export interface Context extends cordis.Context {
[Context.events]: Events<Context>;
export interface Context extends cordis.Context, Pick<WebService, 'Route' | 'Connection' | 'withHandlerClass'> {
// @ts-ignore
[Context.events]: Events<this>;
loader: Loader;
Route: typeof import('./service/server').Route;
Connection: typeof import('./service/server').Connection;
withHandlerClass: import('./service/server').RouteService['withHandlerClass'];
check: CheckService;
setImmediate: typeof setImmediate;
addScript: typeof addScript;
@@ -72,15 +72,6 @@ export class Context extends cordis.Context {
super(config);
this.plugin(ApiMixin);
}
/** @deprecated use `ctx.root` instead */
get app() {
return this.root;
}
}
export namespace Context {
export type Associate<P extends string, C extends Context = Context> = cordis.Context.Associate<P, C>;
}
const old = cordis.Registry.prototype.inject;
packages/hydrooj/src/entry/common.ts
-5
View File
@@ -10,7 +10,6 @@ import yaml from 'js-yaml';
import { Context } from '../context';
import { Logger } from '../logger';
import { PRIV } from '../model/builtin';
import * as bus from '../service/bus';
import { unwrapExports } from '../utils';
const logger = new Logger('common');
@@ -55,7 +54,6 @@ const getLoader = (type: LoadTask, filename: string) => async function loader(pe
}
}
}
await bus.parallel(`app/load/${type}`);
};
export const handler = getLoader('handler', 'handler');
@@ -95,7 +93,6 @@ export async function locale(pending: string[], fail: string[]) {
}
}
}
await bus.parallel('app/load/locale');
}
export async function setting(pending: string[], fail: string[], modelSetting: typeof import('../model/setting')) {
@@ -137,7 +134,6 @@ export async function setting(pending: string[], fail: string[], modelSetting: t
}
}
}
await bus.parallel('app/load/setting');
}
export async function template(pending: string[], fail: string[]) {
@@ -161,5 +157,4 @@ export async function template(pending: string[], fail: string[]) {
}
}
}
await bus.parallel('app/load/template');
}
packages/hydrooj/src/entry/setup.ts
+19 -17
View File
@@ -1,15 +1,12 @@
import http from 'http';
import os from 'os';
import path from 'path';
import cac from 'cac';
import fs from 'fs-extra';
import Koa, { Context } from 'koa';
import Body from 'koa-body';
import type { Context } from 'koa';
import { MongoClient, WriteConcern } from 'mongodb';
import mongoUri from 'mongodb-uri';
import { Logger } from '../logger';
import { Context as PluginContext } from '../context';
const logger = new Logger('setup');
const listenPort = cac().parse().options.port || 8888;
let resolve;
@@ -82,19 +79,24 @@ async function post(ctx: Context) {
}
}
export function load() {
const app = new Koa();
const server = http.createServer(app.callback());
app.keys = ['Hydro'];
app
.use(Body())
.use((ctx) => {
if (ctx.request.method.toLowerCase() === 'post') return post(ctx);
return get(ctx);
export function load(ctx: PluginContext) {
let dispose;
ctx.plugin(require('@hydrooj/framework'), {
keys: [Math.random()],
proxy: false,
upload: false,
port: listenPort,
});
ctx.inject(['server'], ({ server }) => {
dispose = server.addServerLayer('setup', (c) => {
if (c.request.method.toLowerCase() === 'post') return post(c);
return get(c);
});
server.listen(listenPort);
logger.success('Server listening at: %d', listenPort);
});
return new Promise((r) => {
resolve = r;
resolve = () => {
dispose?.();
r(null);
};
});
}
packages/hydrooj/src/entry/worker.ts
+1
View File
@@ -21,6 +21,7 @@ export async function apply(ctx: Context) {
require('../lib/i18n');
require('../utils');
require('../error');
require('../service/bus').apply(ctx);
const config = require('../options')();
if (!process.env.CI && !config) {
logger.info('Starting setup');
packages/hydrooj/src/error.ts
+7 -108
View File
@@ -1,58 +1,12 @@
/* eslint-disable max-len */
/* eslint-disable func-names */
// eslint-disable-next-line simple-import-sort/imports
import {
CreateError as Err,
HydroError, UserFacingError,
BadRequestError, ForbiddenError, NotFoundError,
} from '@hydrooj/framework';
interface IHydroError {
new(...args: any[]): HydroError
}
export class HydroError extends Error {
params: any[];
code: number;
constructor(...params: any[]) {
super();
this.params = params;
}
msg() {
return 'HydroError';
}
get message() {
return this.msg();
}
}
const Err = (name: string, Class: IHydroError, ...info: Array<(() => string) | string | number>) => {
let msg: () => string;
let code: number;
for (const item of info) {
if (typeof item === 'number') {
code = item;
} else if (typeof item === 'string') {
msg = function () { return item; };
} else if (typeof item === 'function') {
msg = item;
}
}
// eslint-disable-next-line @typescript-eslint/no-shadow
return class HydroError extends Class {
name = name;
constructor(...args: any[]) {
super(...args);
if (msg) this.msg = msg;
if (code) this.code = code;
}
};
};
export const UserFacingError = Err('UserFacingError', HydroError, 'UserFacingError', 400);
export const SystemError = Err('SystemError', HydroError, 'SystemError', 500);
export const BadRequestError = Err('BadRequestError', UserFacingError, 'BadRequestError', 400);
export const ForbiddenError = Err('ForbiddenError', UserFacingError, 'ForbiddenError', 403);
export const NotFoundError = Err('NotFoundError', UserFacingError, 'NotFoundError', 404);
export const MethodNotAllowedError = Err('MethodNotAllowedError', UserFacingError, 'MethodNotAllowedError', 405);
export * from '@hydrooj/framework/error';
export const RemoteOnlineJudgeError = Err('RemoteOnlineJudgeError', UserFacingError, 'RemoteOnlineJudgeError', 500);
export const SendMailError = Err('SendMailError', UserFacingError, 'Failed to send mail to {0}. (1)', 500);
@@ -77,16 +31,6 @@ export const PrivilegeError = Err('PrivilegeError', ForbiddenError, function (th
}
return "You don't have the required privilege.";
});
export const ValidationError = Err('ValidationError', ForbiddenError, function (this: HydroError) {
if (this.params.length === 3) {
return this.params[1]
? 'Field {0} or {1} validation failed. ({2})'
: 'Field {0} validation failed. ({2})';
}
return this.params[1]
? 'Field {0} or {1} validation failed.'
: 'Field {0} validation failed.';
});
export const ContestNotAttendedError = Err('ContestNotAttendedError', ForbiddenError, "You haven't attended this contest yet.");
export const RequireProError = Err('RequireProError', ForbiddenError, 'RequireProError');
export const ContestAlreadyAttendedError = Err('ContestAlreadyAttendedError', ForbiddenError, "You've already attended this contest.");
@@ -97,7 +41,6 @@ export const TrainingAlreadyEnrollError = Err('TrainingAlreadyEnrollError', Forb
export const HomeworkNotLiveError = Err('HomeworkNotLiveError', ForbiddenError, 'This homework is not open.');
export const HomeworkNotAttendedError = Err('HomeworkNotAttendedError', ForbiddenError, "You haven't claimed this homework yet.");
export const RoleAlreadyExistError = Err('RoleAlreadyExistError', ForbiddenError, 'This role already exists.');
export const CsrfTokenError = Err('CsrfTokenError', ForbiddenError, 'CsrfTokenError');
export const DomainAlreadyExistsError = Err('DomainAlreadyExistsError', ForbiddenError, 'The domain {0} already exists.');
export const DomainJoinForbiddenError = Err('DomainJoinForbiddenError', ForbiddenError, 'You are not allowed to join the domain. The link is either invalid or expired.');
export const DomainJoinAlreadyMemberError = Err('DomainJoinAlreadyMemberError', ForbiddenError, 'Failed to join the domain. You are already a member.');
@@ -137,48 +80,4 @@ export const ContestNotFoundError = Err('ContestNotFoundError', DocumentNotFound
export const DiscussionNotFoundError = Err('DiscussionNotFoundError', DocumentNotFoundError, 'Discussion {1} not found.');
export const DiscussionNodeNotFoundError = Err('DiscussionNodeNotFoundError', DocumentNotFoundError, 'Discussion node {1} not found.');
export const InvalidOperationError = Err('InvalidOperationError', MethodNotAllowedError);
export const NotLaunchedByPM2Error = Err('NotLaunchedByPM2Error', BadRequestError, 'Not launched by PM2.');
export const FileTooLargeError = Err('FileTooLargeError', ValidationError, 'The uploaded file is too long.');
global.Hydro.error = module.exports;
/*
class FileTypeNotAllowedError(ValidationError):
@property
def message(self):
return 'This type of files are not allowed to be uploaded.'
class InvalidTokenDigestError(ForbiddenError):
pass
class DiscussionCategoryAlreadyExistError(ForbiddenError):
@property
def message(self):
return 'Discussion category {1} already exists.'
class DiscussionCategoryNotFoundError(NotFoundError):
@property
def message(self):
return 'Discussion category {1} not found.'
class DiscussionNodeAlreadyExistError(ForbiddenError):
@property
def message(self):
return 'Discussion node {1} already exists.'
class TrainingRequirementNotSatisfiedError(ForbiddenError):
@property
def message(self):
return 'Training requirement is not satisfied.'
class UsageExceededError(ForbiddenError):
@property
def message(self):
return 'Usage exceeded.'
class InvalidArgumentError(BadRequestError):
@property
def message(self):
return 'Argument {0} is invalid.'
*/
packages/hydrooj/src/lib/avatar.ts
+1 -1
View File
@@ -1,5 +1,5 @@
import { Types } from '@hydrooj/framework/validator';
import { md5 } from '../utils';
import { Types } from './validator';
type AvatarProvider = (src: string, size: number) => string;
packages/hydrooj/src/lib/i18n.ts
+14
View File
@@ -33,6 +33,20 @@ class I18nService extends Service {
}
return null;
}
translate(str: string, languages: string[]) {
if (languages[0]?.startsWith('en')) {
// For most use cases, source text equals to translated text in English.
// So if it doesn't exist, we should use the original text instead of fallback.
return app.i18n.get(str, languages[0]) || app.i18n.get(str, 'en') || this.toString();
}
for (const language of languages.filter(Boolean)) {
const curr = app.i18n.get(str, language) || app.i18n.get(str, language.split('_')[0])
|| app.i18n.get(str, language.split('-')[0]);
if (curr) return curr;
}
return this.toString();
}
}
app.provide('i18n', undefined, true);
packages/hydrooj/src/lib/serializer.ts
-16
View File
@@ -1,16 +0,0 @@
interface SerializeOptions {
showDisplayName: boolean;
currentSerializer?: (k: string, v: any) => any;
}
export default function serializer(options: SerializeOptions, ignoreSerializeFunction = false) {
options.currentSerializer = (k: string, v: any) => {
if (typeof k.startsWith !== 'function') console.log(k, v);
if (k.startsWith('_') && k !== '_id') return undefined;
if (typeof v === 'bigint') return `BigInt::${v.toString()}`;
if (!ignoreSerializeFunction && v && typeof v === 'object'
&& 'serialize' in v && typeof v.serialize === 'function') return v.serialize(options);
return v;
};
return options.currentSerializer;
}
packages/hydrooj/src/lib/validator.ts
-193
View File
@@ -1,193 +0,0 @@
import assert from 'assert';
import emojiRegex from 'emoji-regex';
import { isSafeInteger } from 'lodash';
import moment from 'moment-timezone';
import { ObjectId } from 'mongodb';
import sanitize from 'sanitize-filename';
import saslprep from 'saslprep';
type InputType = string | number | Record<string, any> | any[];
export type Converter<T> = (value: any) => T;
export type Validator<Loose extends boolean = true> = (value: Loose extends true ? any : InputType) => boolean;
export type Type<T> = readonly [Converter<T>, Validator<false>?, (boolean | 'convert')?];
export interface Types {
// String outputs
Content: Type<string>;
Key: Type<string>;
/** @deprecated */
Name: Type<string>;
Username: Type<string>;
Password: Type<string>;
UidOrName: Type<string>;
Email: Type<string>;
Filename: Type<string>;
DomainId: Type<string>;
ProblemId: Type<string | number>;
Role: Type<string>;
Title: Type<string>;
Emoji: Type<string>;
String: Type<string>;
// Number outputs
Int: Type<number>;
UnsignedInt: Type<number>;
PositiveInt: Type<number>;
Float: Type<number>;
// Other
ObjectId: Type<ObjectId>;
Boolean: Type<boolean>;
Date: Type<string>;
Time: Type<string>;
Range: <T extends string | number>(range: Array<T> | Record<string, any>) => Type<T>;
/** @deprecated */
Array: Type<any[]>;
NumericArray: Type<number[]>;
CommaSeperatedArray: Type<string[]>;
Set: Type<Set<any>>;
Any: Type<any>;
ArrayOf: <T extends Type<any>>(type: T) => (T extends Type<infer R> ? Type<R[]> : never);
AnyOf: <T extends Type<any>>(...type: T[]) => (T extends Type<infer R> ? Type<R> : never);
}
const basicString = <T = string>(regex?: RegExp, cb?: (i: string) => boolean, convert?: (i: string) => T) => [
convert || ((v) => v.toString()),
(v) => {
const res = v.toString();
if (regex && !regex.test(res)) return false;
if (cb && !cb(res)) return false;
return !!res.length;
},
] as [(v) => string, (v) => boolean];
const saslprepString = <T = string>(regex?: RegExp, cb?: (i: string) => boolean, convert?: (i: string) => T) => [
convert || ((v) => saslprep(v.toString().trim())),
(v) => {
try {
const res = saslprep(v.toString().trim());
if (regex && !regex.test(res)) return false;
if (cb && !cb(res)) return false;
return !!res.length;
} catch (e) {
return false;
}
},
] as [(v) => string, (v) => boolean];
export const Types: Types = {
Content: [(v) => v.toString().trim(), (v) => v?.toString()?.trim() && v.toString().trim().length < 65536],
Key: saslprepString(/^[a-zA-Z0-9-_]+$/),
/** @deprecated */
Name: saslprepString(/^.{1,255}$/),
Filename: saslprepString(/^[^\\/?#~!|*]{1,255}$/, (i) => sanitize(i) === i),
UidOrName: saslprepString(/^(.{3,31}|[\u4e00-\u9fa5]{2}|-?[0-9]+)$/),
Username: saslprepString(/^(.{3,31}|[\u4e00-\u9fa5]{2})$/),
Password: basicString(/^.{6,255}$/),
ProblemId: saslprepString(/^[a-zA-Z0-9]+$/i, () => true, (s) => (Number.isSafeInteger(+s) ? +s : s)),
Email: saslprepString(/^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)+$/i),
DomainId: saslprepString(/^[a-zA-Z][a-zA-Z0-9_]{3,31}$/),
Role: saslprepString(/^[_0-9A-Za-z\u4e00-\u9fa5]{1,31}$/i),
Title: basicString(/^.{1,64}$/, (i) => !!i.trim()),
String: basicString(),
Int: [(v) => +v, (v) => /^[+-]?[0-9]+$/.test(v.toString().trim()) && isSafeInteger(+v)],
UnsignedInt: [(v) => +v, (v) => /^(-0|\+?[0-9]+)$/.test(v.toString().trim()) && isSafeInteger(+v)],
PositiveInt: [(v) => +v, (v) => /^\+?[1-9][0-9]*$/.test(v.toString().trim()) && isSafeInteger(+v)],
Float: [(v) => +v, (v) => Number.isFinite(+v)],
ObjectId: [(v) => new ObjectId(v), ObjectId.isValid],
Boolean: [(v) => !!(v && !['false', 'off'].includes(v)), null, true],
Date: [
(v) => {
const d = v.split('-');
assert(d.length === 3);
return `${d[0]}-${d[1].length === 1 ? '0' : ''}${d[1]}-${d[2].length === 1 ? '0' : ''}${d[2]}`;
},
(v) => {
const d = v.toString().split('-');
if (d.length !== 3) return false;
const st = `${d[0]}-${d[1].length === 1 ? '0' : ''}${d[1]}-${d[2].length === 1 ? '0' : ''}${d[2]}`;
return moment(st).isValid();
},
],
Time: [
(v) => {
const t = v.split(':');
assert(t.length === 2);
return `${(t[0].length === 1 ? '0' : '') + t[0]}:${t[1].length === 1 ? '0' : ''}${t[1]}`;
},
(v) => {
const t = v.toString().split(':');
if (t.length !== 2) return false;
return moment(`2020-01-01 ${(t[0].length === 1 ? '0' : '') + t[0]}:${t[1].length === 1 ? '0' : ''}${t[1]}`).isValid();
},
],
Range: (range) => [
(v) => {
if (range instanceof Array) {
for (const item of range) {
if (typeof item === 'number' && item === +v) return +v;
if (item === v) return v;
}
}
return v;
},
(v) => {
if (range instanceof Array) {
for (const item of range) {
if (typeof item === 'string' && item === v) return true;
if (typeof item === 'number' && item === +v) return true;
}
} else {
for (const key in range) {
if (key === v) return true;
}
}
return false;
},
],
/** @deprecated suggested to use Types.ArrayOf instead. */
Array: [(v) => {
if (v instanceof Array) return v;
return v ? [v] : [];
}, null],
NumericArray: [(v) => {
if (v instanceof Array) return v.map(Number);
return v.split(',').map(Number);
}, (v) => {
if (v instanceof Array) return v.map(Number).every(Number.isSafeInteger);
return v.toString().split(',').map(Number).every(Number.isSafeInteger);
}],
CommaSeperatedArray: [
(v) => v.toString().replace(/，/g, ',').split(',').map((e) => e.trim()).filter((i) => i),
(v) => !!v.toString(),
],
Set: [(v) => {
if (v instanceof Array) return new Set(v);
return v ? new Set([v]) : new Set();
}, null],
Emoji: [
(v: string) => v.matchAll(emojiRegex()).next().value[0],
(v) => emojiRegex().test(v.toString()),
],
Any: [(v) => v, null],
ArrayOf: (type) => [
(v) => {
const arr = v instanceof Array ? v : [v];
return arr.map((i) => type[0](i));
},
(v) => {
if (!type[1]) return true;
const arr = v instanceof Array ? v : [v];
return arr.every((i) => type[1](i));
},
] as any,
AnyOf: (...types) => [
(v) => types.find((type) => type[1](v))[0](v),
(v) => types.some((type) => type[1](v)),
] as any,
};
// @ts-ignore
Types.ObjectID = Types.ObjectId;
// backward compatibility
packages/hydrooj/src/model/setting.ts
+2 -1
View File
@@ -290,7 +290,7 @@ SystemSetting(
// eslint-disable-next-line import/no-mutable-exports
export const langs: Record<string, LangConfig> = {};
declare module '../context' {
declare module 'cordis' {
interface Context {
setting: SettingService;
}
@@ -319,6 +319,7 @@ export class SettingService extends Service {
}
export async function apply(ctx: Context) {
ctx.provide('setting', undefined, true);
ctx.plugin(SettingService);
logger.info('Ensuring settings');
const system = global.Hydro.model.system;
packages/hydrooj/src/model/user.ts
+8 -4
View File
@@ -1,6 +1,7 @@
import { escapeRegExp, pick, uniq } from 'lodash';
import { LRUCache } from 'lru-cache';
import { Collection, Filter, ObjectId } from 'mongodb';
import { serializer } from '@hydrooj/framework';
import { LoginError, UserAlreadyExistError, UserNotFoundError } from '../error';
import {
Authenticator, BaseUserDict, FileInfo, GDoc,
@@ -8,7 +9,6 @@ import {
} from '../interface';
import avatar from '../lib/avatar';
import pwhash from '../lib/hash.hydro';
import serializer from '../lib/serializer';
import * as bus from '../service/bus';
import db from '../service/db';
import { Value } from '../typeutils';
@@ -165,16 +165,20 @@ export class User {
return user;
}
serialize(options) {
serialize(_, h) {
if (!this._isPrivate) {
const fields = ['_id', 'uname', 'mail', 'perm', 'role', 'priv', 'regat', 'loginat', 'tfa', 'authn'];
if (options.showDisplayName) fields.push('displayName');
if (h?.user?.hasPerm(PERM.PERM_VIEW_DISPLAYNAME)) fields.push('displayName');
return pick(this, fields);
}
return JSON.stringify(this, serializer({ showDisplayName: options.showDisplayName }, true));
return JSON.stringify(this, serializer(true, h));
}
}
declare module '@hydrooj/framework' {
interface UserModel extends User { }
}
function handleMailLower(mail: string) {
const [n, d] = mail.trim().toLowerCase().split('@');
const [name] = n.split('+');
packages/hydrooj/src/plugin-api.ts
+7 -6
View File
@@ -3,6 +3,10 @@ import db from './service/db';
export { nanoid } from 'nanoid';
export {
WebService, Router, HandlerCommon, httpServer,
} from '@hydrooj/framework';
export * from './pipelineUtils';
export * from './error';
export * from './libs';
@@ -33,6 +37,7 @@ export * as JudgeHandler from './handler/judge';
export { registerResolver, registerValue, registerUnion } from './service/api';
export { postJudge } from './handler/judge';
export { Collections } from './service/db';
export { Handler, ConnectionHandler, requireSudo } from './service/server';
export { Service, Context } from './context';
export { buildContent } from './lib/content';
export { default as mime } from './lib/mime';
@@ -40,13 +45,9 @@ export { default as rating } from './lib/rating';
export { default as avatar } from './lib/avatar';
export { default as rank } from './lib/rank';
export { default as paginate } from './lib/paginate';
export * from './lib/validator';
export * from './service/decorators';
export {
Handler, ConnectionHandler, captureAllRoutes,
httpServer, wsServer, router,
} from './service/server';
export { UiContextBase } from './service/layers/base';
export * from '@hydrooj/framework/decorators';
export * from '@hydrooj/framework/validator';
export * as StorageService from './service/storage';
export { EventMap } from './service/bus';
export { db, pwsh };
packages/hydrooj/src/service/bus.ts
+25 -30
View File
@@ -2,7 +2,9 @@
import {
BSON, Db, Filter, ObjectId, OnlyFieldsOfType,
} from 'mongodb';
import type { Handler, ServerEvents } from '@hydrooj/framework';
import pm2 from '@hydrooj/utils/lib/locate-pm2';
import { Context } from '../context';
import type { ProblemSolutionHandler } from '../handler/problem';
import type { UserRegisterHandler } from '../handler/user';
import type {
@@ -11,28 +13,19 @@ import type {
ScoreboardRow, Tdoc, TrainingDoc, User,
} from '../interface';
import type { DocType } from '../model/document';
import type { ConnectionHandler, Handler } from './server';
export type Disposable = () => void;
export type VoidReturn = Promise<any> | any;
type HookType = 'before-prepare' | 'before' | 'before-operation' | 'after' | 'finish';
type ModuleCategories = 'lib' | 'locale' | 'template' | 'script' | 'model' | 'setting' | 'handler' | 'service' | 'addon';
type LifecycleEvents = Record<`app/load/${ModuleCategories}`, () => VoidReturn>;
type MapHandlerEvents<N extends string, H extends Handler> = Record<`handler/${HookType}/${N}`, (thisArg: H) => VoidReturn>;
type KnownHandlerEvents =
MapHandlerEvents<'UserRegister', UserRegisterHandler>
& MapHandlerEvents<'ProblemSolution', ProblemSolutionHandler>;
type HandlerEvents =
KnownHandlerEvents
& Record<`handler/${HookType}/${string}`, (thisArg: Handler & Record<string, any>) => VoidReturn>
& Record<`handler/${HookType}`, (thisArg: Handler) => VoidReturn>
& Record<`handler/register/${string}`, (HandlerClass: typeof Handler) => VoidReturn>
& Record<`connection/${'create' | 'active' | 'close'}`, (thisArg: ConnectionHandler) => VoidReturn>;
/* eslint-disable @typescript-eslint/naming-convention */
export interface EventMap extends LifecycleEvents, HandlerEvents {
'app/started': () => void
export interface EventMap extends KnownHandlerEvents {
'app/listen': () => void
'app/started': () => void
'app/ready': () => VoidReturn
'app/exit': () => VoidReturn
'app/before-reload': (entries: Set<string>) => VoidReturn
@@ -45,7 +38,7 @@ export interface EventMap extends LifecycleEvents, HandlerEvents {
'database/config': () => VoidReturn
'system/setting': (args: Record<string, any>) => VoidReturn
'bus/broadcast': (event: keyof EventMap, ...args: any[]) => VoidReturn
'bus/broadcast': (event: keyof EventMap | keyof ServerEvents, payload: any) => VoidReturn
'monitor/update': (type: 'server' | 'judge', $set: any) => VoidReturn
'monitor/collect': (info: any) => VoidReturn
'api/update': () => void;
@@ -69,10 +62,6 @@ export interface EventMap extends LifecycleEvents, HandlerEvents {
$set: any, $unset: OnlyFieldsOfType<DocType[T], any, true | '' | 1>
) => VoidReturn
'handler/create': (thisArg: Handler) => VoidReturn
'handler/init': (thisArg: Handler) => VoidReturn
'handler/error': (thisArg: Handler, e: Error) => VoidReturn
'discussion/before-add': (payload: Partial<DiscussionDoc>) => VoidReturn
'discussion/add': (payload: Partial<DiscussionDoc>) => VoidReturn
@@ -108,21 +97,27 @@ export interface EventMap extends LifecycleEvents, HandlerEvents {
}
/* eslint-enable @typescript-eslint/naming-convention */
try {
if (!process.send || !pm2 || process.env.exec_mode !== 'cluster_mode') throw new Error();
pm2.launchBus((err, bus) => {
if (err) throw new Error();
bus.on('hydro:broadcast', (packet) => {
(app.parallel as any)(packet.data.event, ...BSON.EJSON.parse(packet.data.payload));
declare module 'cordis' {
interface Events extends EventMap { }
}
export function apply(ctx: Context) {
try {
if (!process.send || !pm2 || process.env.exec_mode !== 'cluster_mode') throw new Error();
pm2.launchBus((err, bus) => {
if (err) throw new Error();
bus.on('hydro:broadcast', (packet) => {
(app.parallel as any)(packet.data.event, ...BSON.EJSON.parse(packet.data.payload));
});
ctx.on('bus/broadcast', (event, payload) => {
process.send({ type: 'hydro:broadcast', data: { event, payload: BSON.EJSON.stringify(payload) } });
});
console.debug('Using pm2 event bus');
});
app.on('bus/broadcast', (event, payload) => {
process.send({ type: 'hydro:broadcast', data: { event, payload: BSON.EJSON.stringify(payload) } });
});
console.debug('Using pm2 event bus');
});
} catch (e) {
app.on('bus/broadcast', (event, payload) => app.parallel(event, ...payload));
console.debug('Using mongodb external event bus');
} catch (e) {
ctx.on('bus/broadcast', (event, payload) => app.parallel(event, ...payload));
console.debug('Using mongodb external event bus');
}
}
export default app;
packages/hydrooj/src/service/decorators.ts
-133
View File
@@ -1,133 +0,0 @@
import { Time } from '@hydrooj/utils';
import { ValidationError } from '../error';
import { Converter, Type, Validator } from '../lib/validator';
import { EventMap } from './bus';
import type { Handler } from './server';
type MethodDecorator = (target: any, funcName: string, obj: any) => any;
type ClassDecorator = <T extends new (...args: any[]) => any>(Class: T) => T extends new (...args: infer R) => infer S
? new (...args: R) => S : never;
export interface ParamOption<T> {
name: string,
source: 'all' | 'get' | 'post' | 'route',
isOptional?: boolean | 'convert',
convert?: Converter<T>,
validate?: Validator,
}
function _buildParam(name: string, source: 'get' | 'post' | 'all' | 'route', ...args: Array<Type<any> | boolean | Validator | Converter<any>>) {
let cursor = 0;
const v: ParamOption<any> = { name, source };
let isValidate = true;
while (cursor < args.length) {
const current = args[cursor];
if (current instanceof Array) {
const type = current;
if (type[0]) v.convert = type[0];
if (type[1]) v.validate = type[1];
if (type[2]) v.isOptional = type[2];
} else if (typeof current === 'boolean') v.isOptional = current;
else if (isValidate) {
if (current !== null) v.validate = current;
isValidate = false;
} else v.convert = current;
cursor++;
}
return v;
}
function _descriptor(v: ParamOption<any>) {
return function desc(this: Handler, target: any, funcName: string, obj: any) {
target.__param ||= {};
target.__param[target.constructor.name] ||= {};
if (!target.__param[target.constructor.name][funcName]) {
const originalMethod = obj.value;
const val = originalMethod.toString();
const firstArg = val.split(')')[0]?.split(',')[0]?.split('(')[1]?.trim() || '';
const domainIdStyle = firstArg.toLowerCase().startsWith('domainid');
target.__param[target.constructor.name][funcName] = [];
obj.value = function validate(this: Handler, rawArgs: any, ...extra: any[]) {
if (typeof rawArgs !== 'object' || extra.length) return originalMethod.call(this, rawArgs, ...extra);
const c = [];
const arglist: ParamOption<any>[] = target.__param[target.constructor.name][funcName];
if (typeof rawArgs.domainId !== 'string' || !rawArgs.domainId) throw new ValidationError('domainId');
for (const item of arglist) {
const src = item.source === 'all'
? rawArgs
: item.source === 'get'
? this.request.query
: item.source === 'route'
? { ...this.request.params, domainId: this.args.domainId }
: this.request.body;
const value = src[item.name];
if (!item.isOptional || value) {
if (value === undefined || value === null || value === '') throw new ValidationError(item.name);
if (item.validate && !item.validate(value)) throw new ValidationError(item.name);
if (item.convert) c.push(item.convert(value));
else c.push(value);
} else if (item.isOptional === 'convert') {
c.push(item.convert ? item.convert(value) : value);
} else c.push(undefined);
}
return domainIdStyle ? originalMethod.call(this, rawArgs.domainId, ...c) : originalMethod.call(this, rawArgs, ...c);
};
}
target.__param[target.constructor.name][funcName].unshift(v);
return obj;
};
}
type DescriptorBuilder =
((name: string, type: Type<any>) => MethodDecorator)
& ((name: string, type: Type<any>, validate: null, convert: Converter<any>) => MethodDecorator)
& ((name: string, type: Type<any>, validate?: Validator, convert?: Converter<any>) => MethodDecorator)
& ((name: string, type?: Type<any>, isOptional?: boolean, validate?: Validator, convert?: Converter<any>) => MethodDecorator)
& ((name: string, ...args: Array<Type<any> | boolean | Validator | Converter<any>>) => MethodDecorator);
export const get: DescriptorBuilder = (name, ...args) => _descriptor(_buildParam(name, 'get', ...args));
export const query: DescriptorBuilder = (name, ...args) => _descriptor(_buildParam(name, 'get', ...args));
export const post: DescriptorBuilder = (name, ...args) => _descriptor(_buildParam(name, 'post', ...args));
export const route: DescriptorBuilder = (name, ...args) => _descriptor(_buildParam(name, 'route', ...args));
export const param: DescriptorBuilder = (name, ...args) => _descriptor(_buildParam(name, 'all', ...args));
export const subscribe: (name: keyof EventMap) => MethodDecorator & ClassDecorator = (name) => (target, funcName?, obj?) => {
if (funcName) {
target.__subscribe ||= [];
target.__subscribe.push({ name, target: obj.value });
return obj;
}
return (...args) => {
const c = new target(...args); // eslint-disable-line new-cap
c.__subscribe = [{ name, target: c.send }];
return c;
};
};
/*
* For security concern, some API requires sudo privilege to access.
* And for some superadmin operations,
* we do not allow them using a password to perform the sudo operation,
* as most user choose to use "remember password" option.
* When teachers are using a superuser account, accessing from classrooms,
* it may lead to serious security issues.
* !!! Please make sure that all superuser accounts have two factor authentication enabled. !!!
*/
export function requireSudo(target: any, funcName: string, obj: any) {
const originalMethod = obj.value;
obj.value = function sudo(this: Handler, ...args: any[]) {
if (this.session.sudo && Date.now() - this.session.sudo < Time.hour) {
if (this.session.sudoArgs?.referer) this.request.headers.referer = this.session.sudoArgs.referer;
this.session.sudoArgs = null;
return originalMethod.call(this, ...args);
}
this.session.sudoArgs = {
method: this.request.method,
referer: this.request.headers.referer,
args: this.args,
redirect: this.request.originalPath,
};
this.response.redirect = this.url('user_sudo');
return 'cleanup';
};
return obj;
}
packages/hydrooj/src/service/layers/base.ts
+6 -41
View File
@@ -1,11 +1,10 @@
import { PassThrough } from 'stream';
import type { Next } from 'koa';
import { cloneDeep, omit, pick } from 'lodash';
import { cloneDeep, omit } from 'lodash';
import type { KoaContext } from '@hydrooj/framework';
import { randomPick } from '@hydrooj/utils';
import { PERM } from '../../model/builtin';
import * as system from '../../model/system';
import token from '../../model/token';
import type { HydroRequest, HydroResponse, KoaContext } from '../server';
export interface UiContextBase {
cdn_prefix: string;
@@ -21,41 +20,6 @@ export const UiContextBase: UiContextBase = {
export default async (ctx: KoaContext, next: Next) => {
// Base Layer
const { domainId, domainInfo } = ctx;
const [xff, xhost] = system.getMany(['server.xff', 'server.xhost']);
const request: HydroRequest = {
method: ctx.request.method.toLowerCase(),
host: ctx.request.headers[xhost?.toLowerCase() || ''] as string || ctx.request.host,
hostname: ctx.request.hostname,
ip: ctx.request.headers[xff?.toLowerCase() || ''] as string || ctx.request.ip,
headers: ctx.request.headers,
cookies: ctx.cookies,
...pick(ctx, ['query', 'path', 'params', 'originalPath', 'querystring']),
body: ctx.request.body,
files: ctx.request.files as any,
referer: ctx.request.headers.referer || '',
json: (ctx.request.headers.accept || '').includes('application/json'),
websocket: ctx.request.headers.upgrade === 'websocket',
};
request.ip = request.ip.split(',')[0].trim();
const response: HydroResponse = {
body: {},
type: '',
status: null,
template: null,
redirect: null,
attachment: (name, streamOrBuffer) => {
ctx.attachment(name);
if (streamOrBuffer instanceof Buffer) {
response.body = null;
ctx.body = streamOrBuffer;
} else {
response.body = null;
ctx.body = streamOrBuffer.pipe(new PassThrough());
}
},
addHeader: (name: string, value: string) => ctx.set(name, value),
disposition: null,
};
const args = {
domainId, ...ctx.params, ...ctx.query, ...ctx.request.body, __start: Date.now(),
};
@@ -68,9 +32,9 @@ export default async (ctx: KoaContext, next: Next) => {
}
UiContext.domainId = domainId;
UiContext.domain = domainInfo;
ctx.HydroContext = {
request, response, UiContext, domain: domainInfo, user: null, args,
};
ctx.HydroContext.UiContext = UiContext;
ctx.HydroContext.domain = domainInfo;
ctx.HydroContext.args = args;
const header = ctx.request.headers.authorization;
const sid = header
? header.split(' ')[1] // Accept bearer token
@@ -78,6 +42,7 @@ export default async (ctx: KoaContext, next: Next) => {
const session = sid ? await token.get(sid instanceof Array ? sid[0] : sid, token.TYPE_SESSION) : null;
ctx.session = Object.create(session || { uid: 0, scope: PERM.PERM_ALL.toString() });
await next();
const request = ctx.HydroContext.request;
const ua = request.headers['user-agent'] || '';
if (!ctx.session.uid && system.get('server.ignoreUA').replace(/\r/g, '').split('\n').filter((i) => i && ua.includes(i)).length) return;
const expireSeconds = ctx.session.save
packages/hydrooj/src/service/layers/domain.ts
+1 -1
View File
@@ -1,7 +1,7 @@
import { KoaContext } from '@hydrooj/framework';
import BlackListModel from '../../model/blacklist';
import DomainModel from '../../model/domain';
import * as system from '../../model/system';
import { KoaContext } from '../server';
export default async (ctx: KoaContext, next) => {
const forceDomain = /^\/d\/([^/]+)\//.exec(ctx.request.path);
packages/hydrooj/src/service/layers/renderer.ts
-78
View File
@@ -1,78 +0,0 @@
import { ObjectId } from 'mongodb';
import avatar from '../../lib/avatar';
import serializer from '../../lib/serializer';
import { PERM } from '../../model/builtin';
import * as system from '../../model/system';
import type { KoaContext } from '../server';
export default (router, logger) => async (ctx: KoaContext, next) => {
const { request, response } = ctx.HydroContext;
ctx.renderHTML = (templateName, args) => {
const user = ctx.HydroContext.user;
const UserContext: any = {
...(user || {}),
avatar: avatar(user?.avatar || '', 128),
viewLang: ctx.translate('__id'),
};
const type = templateName.split('.')[1];
const engine = global.Hydro.module.render[type]
|| (() => JSON.stringify(args, serializer({
showDisplayName: user?.hasPerm(PERM.PERM_VIEW_DISPLAYNAME),
})));
return engine(templateName, {
handler: ctx.handler,
UserContext,
url: ctx.getUrl,
_: ctx.translate,
...args,
});
};
ctx.render = async (name, args) => {
response.body = await ctx.renderHTML(name, args);
response.type = 'text/html';
};
ctx.getUrl = (name: string, ...kwargsList: Record<string, any>[]) => {
if (name === '#') return '#';
let res = '#';
const args: any = {};
const query: any = {};
for (const kwargs of kwargsList) {
for (const key in kwargs) {
if (kwargs[key] instanceof ObjectId) args[key] = kwargs[key].toHexString();
else args[key] = kwargs[key].toString().replace(/\//g, '%2F');
}
for (const key in kwargs.query || {}) {
if (query[key] instanceof ObjectId) query[key] = kwargs.query[key].toHexString();
else query[key] = kwargs.query[key].toString();
}
}
try {
const { anchor } = args;
let withDomainId = args.domainId || false;
const domainId = ctx.HydroContext.args.domainId;
const host = ctx.HydroContext.domain?.host;
if (domainId !== 'system' && (
!request.host
|| (host instanceof Array
? (!host.includes(request.host))
: request.host !== host)
)) withDomainId ||= domainId;
res = router.url(name, args, { query }).toString();
if (anchor) res = `${res}#${anchor}`;
if (withDomainId) res = `/d/${withDomainId}${res}`;
} catch (e) {
logger.warn(e.message);
logger.info('%s %o', name, args);
if (!e.message.includes('Expected') || !e.message.includes('to match')) logger.info('%s', e.stack);
}
return res;
};
ctx.translate = (str: string) => {
if (!str) return '';
const lang = ctx.HydroContext.user?.viewLang || ctx.session?.viewLang;
return lang
? str.toString().translate(lang, ...ctx.acceptsLanguages())
: str.toString().translate(...ctx.acceptsLanguages(), system.get('server.language'));
};
await next();
};
packages/hydrooj/src/service/layers/response.ts
-75
View File
@@ -1,75 +0,0 @@
import { errorMessage } from '@hydrooj/utils/lib/utils';
import { SystemError, UserFacingError } from '../../error';
import serializer from '../../lib/serializer';
import { PERM } from '../../model/builtin';
import type { KoaContext } from '../server';
export default (logger) => async (ctx: KoaContext, next) => {
const { request, response } = ctx.HydroContext;
try {
await next();
const { UiContext, user, args } = ctx.HydroContext;
if (response.redirect) {
response.body ||= {};
response.body.url = response.redirect;
}
if (!response.type) {
if (response.pjax && args.pjax) {
const html = await ctx.renderHTML(response.pjax, response.body);
response.body = { fragments: [{ html }] };
response.type = 'application/json';
} else if (
request.json || response.redirect
|| request.query.noTemplate || !response.template) {
// Send raw data
try {
if (typeof response.body === 'object') {
response.body.UiContext = UiContext;
response.body.UserContext = user;
}
response.body = JSON.stringify(response.body, serializer({ showDisplayName: user?.hasPerm(PERM.PERM_VIEW_DISPLAYNAME) }));
} catch (e) {
response.body = new SystemError('Serialize failure', e.message);
}
response.type = 'application/json';
} else if (response.template) {
const s = response.template.split('.');
let templateName = `${s[0]}.${args.domainId}.${s[1]}`;
if (!global.Hydro.ui.template[templateName]) templateName = response.template;
await ctx.render(templateName, response.body || {});
}
}
if (response.disposition) ctx.set('Content-Disposition', response.disposition);
if (response.etag) {
ctx.set('ETag', response.etag);
ctx.set('Cache-Control', 'public');
}
} catch (err) {
const error = errorMessage(err);
response.status = error instanceof UserFacingError ? error.code : 500;
if (request.json) response.body = { error };
else {
try {
await ctx.render(error instanceof UserFacingError ? 'error.html' : 'bsod.html', { UserFacingError, error });
} catch (e) {
logger.error(e);
// this.response.body.error = {};
}
}
} finally {
if (response.etag && request.headers['if-none-match'] === response.etag) {
ctx.response.status = 304;
} else if (response.redirect && !request.json) {
ctx.response.type = 'application/octet-stream';
ctx.response.status = 302;
ctx.redirect(response.redirect);
} else if (response.body) {
ctx.body = response.body;
ctx.response.status = response.status || 200;
ctx.response.type = response.type
|| (request.json
? 'application/json'
: ctx.response.type);
}
}
};
packages/hydrooj/src/service/layers/user.ts
+1 -1
View File
@@ -1,7 +1,7 @@
import type { KoaContext } from '@hydrooj/framework';
import { NotFoundError } from '../../error';
import { PERM } from '../../model/builtin';
import UserModel from '../../model/user';
import type { KoaContext } from '../server';
export default async (ctx: KoaContext, next) => {
// User Layer
packages/hydrooj/src/service/router.ts
-60
View File
@@ -1,60 +0,0 @@
import { IncomingMessage } from 'http';
import KoaRouter from 'koa-router';
import { pathToRegexp } from 'path-to-regexp';
import type WebSocket from 'ws';
import type { KoaContext } from './server';
type WebSocketCallback = (socket: WebSocket, request: IncomingMessage, ctx: KoaContext) => void;
function remove<T>(list: T[], item: T) {
const index = list.indexOf(item);
if (index >= 0) list.splice(index, 1);
}
export class WebSocketLayer {
clients = new Set<WebSocket>();
regexp: RegExp;
constructor(path: Parameters<typeof pathToRegexp>[0], public callback?: WebSocketCallback) {
this.regexp = pathToRegexp(path);
}
accept(socket: WebSocket, request: IncomingMessage, ctx: KoaContext) {
if (!this.regexp.test(new URL(request.url, `http://${request.headers.host}`).pathname)) return false;
this.clients.add(socket);
socket.on('close', () => {
this.clients.delete(socket);
});
this.callback?.(socket, request, ctx);
return true;
}
close() {
for (const socket of this.clients) {
socket.close();
}
}
}
export class Router extends KoaRouter {
wsStack: WebSocketLayer[] = [];
disposeLastOp = () => null;
/**
* hack into router methods to make sure that koa middlewares are disposable
*/
register(...args: Parameters<KoaRouter['register']>) {
const layer = super.register(...args);
this.disposeLastOp = () => remove(this.stack, layer);
return layer;
}
ws(path: Parameters<typeof pathToRegexp>[0], callback?: WebSocketCallback) {
const layer = new WebSocketLayer(path, callback);
this.wsStack.push(layer);
this.disposeLastOp = () => {
layer.close();
remove(this.wsStack, layer);
};
return layer;
}
}
packages/hydrooj/src/service/server.ts
+202 -591
View File
@@ -1,222 +1,83 @@
import http from 'http';
import { tmpdir } from 'os';
import { join, resolve } from 'path';
import fs from 'fs';
import { resolve } from 'path';
import cac from 'cac';
import type { Files } from 'formidable';
import fs from 'fs-extra';
import Koa from 'koa';
import Body from 'koa-body';
import Compress from 'koa-compress';
import proxy from 'koa-proxies';
import cache from 'koa-static-cache';
import type { FindCursor } from 'mongodb';
import { Shorty } from 'shorty.js';
import WebSocket from 'ws';
import { Counter, isClass, parseMemoryMB } from '@hydrooj/utils/lib/utils';
import { Context, Service } from '../context';
import { type FindCursor, ObjectId } from 'mongodb';
import {
CsrfTokenError, HydroError, InvalidOperationError,
MethodNotAllowedError, NotFoundError, PermissionError,
PrivilegeError, UserFacingError,
} from '../error';
import { DomainDoc } from '../interface';
ConnectionHandler as ConnectionHandlerOriginal, Handler as HandlerOriginal, HydroError, NotFoundError, UserFacingError,
} from '@hydrooj/framework';
import { errorMessage, Time } from '@hydrooj/utils';
import { Context } from '../context';
import { PermissionError, PrivilegeError } from '../error';
import type { DomainDoc } from '../interface';
import paginate from '../lib/paginate';
import serializer from '../lib/serializer';
import { Types } from '../lib/validator';
import { Logger } from '../logger';
import { PERM, PRIV } from '../model/builtin';
import * as opcount from '../model/opcount';
import * as OplogModel from '../model/oplog';
import * as system from '../model/system';
import { User } from '../model/user';
import { builtinConfig } from '../settings';
import { errorMessage } from '../utils';
import * as bus from './bus';
import * as decorators from './decorators';
import baseLayer from './layers/base';
import domainLayer from './layers/domain';
import rendererLayer from './layers/renderer';
import responseLayer from './layers/response';
import userLayer from './layers/user';
import { Router } from './router';
import { encodeRFC5987ValueChars } from './storage';
export * from './decorators';
export * from '../lib/validator';
export interface HydroRequest {
method: string;
host: string;
hostname: string;
ip: string;
headers: Koa.Request['headers'];
cookies: any;
body: any;
files: Record<string, import('formidable').File>;
query: any;
querystring: string;
path: string;
originalPath: string;
params: any;
referer: string;
json: boolean;
websocket: boolean;
}
export interface HydroResponse {
body: any;
type: string;
status: number;
template?: string;
/** If set, and pjax content was request from client,
* The template will be used for rendering.
*/
pjax?: string;
redirect?: string;
disposition?: string;
etag?: string;
attachment: (name: string, stream?: any) => void;
addHeader: (name: string, value: string) => void;
}
interface HydroContext {
request: HydroRequest;
response: HydroResponse;
user: User;
domain?: DomainDoc;
args: Record<string, any>;
UiContext: Record<string, any>;
}
export interface KoaContext extends Koa.Context {
HydroContext: HydroContext;
handler: any;
request: Koa.Request & { body: any, files: Files };
session: Record<string, any>;
render: (name: string, args: any) => Promise<void>;
renderHTML: (name: string, args: any) => string | Promise<string>;
getUrl: (name: string, args: any) => string;
translate: (key: string) => string;
}
const argv = cac().parse();
const logger = new Logger('server');
export const app = new Koa<Koa.DefaultState, KoaContext>({
keys: system.get('server.keys'),
});
export const router = new Router();
export const httpServer = http.createServer(app.callback());
export const wsServer = new WebSocket.Server({ server: httpServer });
export const captureAllRoutes = {};
app.proxy = !!system.get('server.xproxy') || !!system.get('server.xff');
app.on('error', (error) => {
if (error.code !== 'EPIPE' && error.code !== 'ECONNRESET' && !error.message.includes('Parse Error')) {
logger.error('Koa app-level error', { error });
}
});
wsServer.on('error', (error) => {
console.log('Websocket server error:', error);
});
const ignoredLimit = `,${argv.options.ignoredLimit},`;
export class HandlerCommon {
render: (name: string, args?: any) => Promise<void>;
renderHTML: (name: string, args?: any) => string | Promise<string>;
url: (name: string, args?: any) => string;
translate: (key: string) => string;
session: Record<string, any>;
ctx: Context;
/** @deprecated */
domainId: string;
const logger = new Logger('server');
constructor(
public context: KoaContext, public readonly args: Record<string, any>,
public readonly request: HydroRequest, public response: HydroResponse,
public user: User, public domain: DomainDoc, public UiContext: Record<string, any>,
) {
this.render = context.render.bind(context);
this.renderHTML = context.renderHTML.bind(context);
this.url = context.getUrl.bind(context);
this.translate = context.translate.bind(context);
this.session = context.session;
this.domainId = args.domainId;
this.ctx = global.app.extend({
domain: this.domain,
});
}
declare module '@hydrooj/framework' {
export interface HandlerCommon {
domain: DomainDoc;
async limitRate(op: string, periodSecs: number, maxOperations: number, withUserId = system.get('limit.by_user')) {
if (ignoredLimit.includes(op)) return;
if (this.user && this.user.hasPriv(PRIV.PRIV_UNLIMITED_ACCESS)) return;
const overrideLimit = system.get(`limit.${op}`);
if (overrideLimit) maxOperations = overrideLimit;
let id = this.request.ip;
if (withUserId) id += `@${this.user._id}`;
await opcount.inc(op, id, periodSecs, maxOperations);
}
paginate<T>(cursor: FindCursor<T>, page: number, key: string) {
return paginate(cursor, page, this.ctx.setting.get(`pagination.${key}`));
}
renderTitle(str: string) {
const name = this.ctx.setting.get('server.name');
if (this.UiContext.extraTitleContent) return `${this.translate(str)} - ${this.UiContext.extraTitleContent} - ${name}`;
return `${this.translate(str)} - ${name}`;
}
checkPerm(...args: bigint[]) {
if (!this.user.hasPerm(...args)) {
if (this.user.hasPriv(PRIV.PRIV_USER_PROFILE)) throw new PermissionError(...args);
throw new PrivilegeError(PRIV.PRIV_USER_PROFILE);
}
}
checkPriv(...args: number[]) {
if (!this.user.hasPriv(...args)) throw new PrivilegeError(...args);
paginate<T>(cursor: FindCursor<T>, page: number, key: string): Promise<[docs: T[], numPages: number, count: number]>;
progress(message: string, params: any[]): void;
limitRate(op: string, periodSecs: number, maxOperations: number, withUserId?: boolean): Promise<void>;
renderTitle(str: string): string;
}
}
export class Handler extends HandlerCommon {
loginMethods: any;
noCheckPermView = false;
notUsage = false;
allowCors = false;
__param: Record<string, decorators.ParamOption<any>[]>;
export * from '@hydrooj/framework/decorators';
export * from '@hydrooj/framework/validator';
back(body?: any) {
this.response.body = body || this.response.body || {};
this.response.redirect = this.request.headers.referer || '/';
}
binary(data: any, name?: string) {
this.response.body = data;
this.response.template = null;
this.response.type = 'application/octet-stream';
if (name) this.response.disposition = `attachment; filename="${encodeRFC5987ValueChars(name)}"`;
}
// This is beta API, may be changed in the future.
progress(message: string, params: any[]) {
Hydro.model.message.sendInfo(this.user._id, JSON.stringify({ message, params }));
}
async init() {
if (this.request.method === 'post' && this.request.headers.referer && !this.context.cors && !this.allowCors) {
try {
const host = new URL(this.request.headers.referer).host;
if (host !== this.request.host) this.context.pendingError = new CsrfTokenError(host);
} catch (e) {
this.context.pendingError = new CsrfTokenError();
}
/*
* For security concern, some API requires sudo privilege to access.
* And for some superadmin operations,
* we do not allow them using a password to perform the sudo operation,
* as most user choose to use "remember password" option.
* When teachers are using a superuser account, accessing from classrooms,
* it may lead to serious security issues.
* !!! Please make sure that all superuser accounts have two factor authentication enabled. !!!
*/
export function requireSudo(target: any, funcName: string, obj: any) {
const originalMethod = obj.value;
obj.value = function sudo(this: Handler, ...args: any[]) {
if (this.session.sudo && Date.now() - this.session.sudo < Time.hour) {
if (this.session.sudoArgs?.referer) this.request.headers.referer = this.session.sudoArgs.referer;
this.session.sudoArgs = null;
return originalMethod.call(this, ...args);
}
if (!argv.options.benchmark && !this.notUsage) await this.limitRate('global', 5, 100);
if (!this.noCheckPermView && !this.user.hasPriv(PRIV.PRIV_VIEW_ALL_DOMAIN)) this.checkPerm(PERM.PERM_VIEW);
this.loginMethods = Object.keys(global.Hydro.module.oauth)
.map((key) => ({
id: key,
icon: global.Hydro.module.oauth[key].icon,
text: global.Hydro.module.oauth[key].text,
}));
if (this.context.pendingError) throw this.context.pendingError;
this.session.sudoArgs = {
method: this.request.method,
referer: this.request.headers.referer,
args: this.args,
redirect: this.request.originalPath,
};
this.response.redirect = this.url('user_sudo');
return 'cleanup';
};
return obj;
}
export interface Handler {
domain: DomainDoc;
ctx: Context;
}
export class Handler extends HandlerOriginal {
constructor(_, ctx: Context) {
super(_, ctx);
this.ctx = ctx.extend({ domain: this.domain });
}
async onerror(error: HydroError) {
@@ -235,6 +96,7 @@ export class Handler extends HandlerCommon {
});
} else {
this.response.status = error instanceof UserFacingError ? error.code : 500;
logger.error(error);
this.response.template = error instanceof UserFacingError ? 'error.html' : 'bsod.html';
this.response.body = {
UserFacingError,
@@ -244,425 +106,174 @@ export class Handler extends HandlerCommon {
}
}
async function serial(name: string, ...args: any[]) {
const r = await (global.app.serial as any)(name, ...args);
if (r instanceof Error) throw r;
return r;
export interface ConnectionHandler {
domain: DomainDoc;
ctx: Context;
}
async function handle(ctx: KoaContext, HandlerClass, checker) {
const {
args, request, response, user, domain, UiContext,
} = ctx.HydroContext;
Object.assign(args, ctx.params);
const init = Date.now();
const h = new HandlerClass(ctx, args, request, response, user, domain, UiContext);
ctx.handler = h;
const method = ctx.method.toLowerCase();
try {
const operation = (method === 'post' && ctx.request.body?.operation)
? `_${ctx.request.body.operation}`.replace(/_([a-z])/gm, (s) => s[1].toUpperCase())
: '';
await bus.parallel('handler/create', h);
if (checker) checker.call(h);
if (method === 'post') {
if (operation) {
if (typeof h[`post${operation}`] !== 'function') {
throw new InvalidOperationError(operation);
}
} else if (typeof h.post !== 'function') {
throw new MethodNotAllowedError(method);
}
} else if (typeof h[method] !== 'function' && typeof h.all !== 'function') {
throw new MethodNotAllowedError(method);
}
const name = HandlerClass.name.replace(/Handler$/, '');
const steps = [
'init', 'handler/init',
`handler/before-prepare/${name}#${method}`, `handler/before-prepare/${name}`, 'handler/before-prepare',
'log/__prepare', '__prepare', '_prepare', 'prepare', 'log/__prepareDone',
`handler/before/${name}#${method}`, `handler/before/${name}`, 'handler/before',
'log/__method', 'all', method, 'log/__methodDone',
...operation ? [
`handler/before-operation/${name}`, 'handler/before-operation',
`post${operation}`, 'log/__operationDone',
] : [], 'after',
`handler/after/${name}#${method}`, `handler/after/${name}`, 'handler/after',
'cleanup',
`handler/finish/${name}#${method}`, `handler/finish/${name}`, 'handler/finish',
];
let current = 0;
while (current < steps.length) {
const step = steps[current];
let control;
if (step.startsWith('log/')) h.args[step.slice(4)] = Date.now();
// eslint-disable-next-line no-await-in-loop
else if (step.startsWith('handler/')) control = await serial(step, h);
// eslint-disable-next-line no-await-in-loop
else if (typeof h[step] === 'function') control = await h[step](args);
if (control) {
const index = steps.findIndex((i) => control === i);
if (index === -1) throw new Error(`Invalid control: ${control}`);
if (index <= current) {
logger.warn('Returning to previous step is not recommended:', step, '->', control);
}
current = index;
} else current++;
}
} catch (e) {
try {
await serial(`handler/error/${HandlerClass.name.replace(/Handler$/, '')}`, h, e);
await serial('handler/error', h, e);
await h.onerror(e);
} catch (err) {
h.response.code = 500;
h.response.type = 'text/plain';
h.response.body = `${err.message}\n${err.stack}`;
}
} finally {
const finish = Date.now();
if (finish - init > 5000) {
const id = await OplogModel.log(h, 'slow_request', { method, processtime: finish - init });
logger.warn(`Slow handler: ID=${id}, `, method, ctx.path, `${finish - init}ms`);
}
// TODO metrics: calc avg response time
}
}
const Checker = (permPrivChecker) => {
let perm: bigint;
let priv: number;
let checker = () => { };
for (const item of permPrivChecker) {
if (typeof item === 'object') {
if (typeof item.call !== 'undefined') {
checker = item;
} else if (typeof item[0] === 'number') {
priv = item;
} else if (typeof item[0] === 'bigint') {
perm = item;
}
} else if (typeof item === 'number') {
priv = item;
} else if (typeof item === 'bigint') {
perm = item;
}
}
return function check(this: Handler) {
checker();
if (perm) this.checkPerm(perm);
if (priv) this.checkPriv(priv);
};
};
export function Route(name: string, path: string, RouteHandler: any, ...permPrivChecker) {
router.all(name, path, (ctx) => handle(ctx as any, RouteHandler, Checker(permPrivChecker)));
return router.disposeLastOp;
}
export class ConnectionHandler extends HandlerCommon {
conn: WebSocket;
compression: Shorty;
counter = 0;
resetCompression() {
this.counter = 0;
this.compression = new Shorty();
this.conn.send('shorty');
}
send(data: any) {
let payload = JSON.stringify(data, serializer({
showDisplayName: this.user?.hasPerm(PERM.PERM_VIEW_DISPLAYNAME),
}));
if (this.compression) {
if (this.counter > 1000) this.resetCompression();
payload = this.compression.deflate(payload);
this.counter++;
}
this.conn.send(payload);
}
close(code: number, reason: string) {
this.conn.close(code, reason);
export class ConnectionHandler extends ConnectionHandlerOriginal {
constructor(_, ctx: Context) {
super(_, ctx);
this.ctx = ctx.extend({ domain: this.domain });
}
onerror(err: HydroError) {
if (err instanceof UserFacingError) err.stack = this.request.path;
if (!(err instanceof NotFoundError)
&& !((err instanceof PrivilegeError || err instanceof PermissionError) && this.user?._id === 0)) {
logger.error(`Path:${this.request.path}, User:${this.user?._id}(${this.user?.uname})`);
logger.error(err);
}
this.send({
error: {
name: err.name,
params: err.params || [],
},
});
this.close(4000, err.toString());
super.onerror(err);
}
}
export function Connection(
name: string, prefix: string,
RouteConnHandler: any,
...permPrivChecker: Array<number | bigint | Function>
) {
const checker = Checker(permPrivChecker);
const layer = router.ws(prefix, async (conn, _, ctx) => {
const {
args, request, response, user, domain, UiContext,
} = ctx.HydroContext;
const h = new RouteConnHandler(ctx, args, request, response, user, domain, UiContext);
await bus.parallel('connection/create', h);
ctx.handler = h;
h.conn = conn;
const disposables = [];
try {
checker.call(h);
if (args.shorty) h.resetCompression();
if (h._prepare) await h._prepare(args);
if (h.prepare) await h.prepare(args);
// eslint-disable-next-line @typescript-eslint/no-shadow
for (const { name, target } of h.__subscribe || []) disposables.push(bus.on(name, target.bind(h)));
let lastHeartbeat = Date.now();
let closed = false;
let interval: NodeJS.Timeout;
const clean = () => {
if (closed) return;
closed = true;
bus.emit('connection/close', h);
layer.clients.delete(conn);
if (interval) clearInterval(interval);
for (const d of disposables) d();
h.cleanup?.(args);
};
interval = setInterval(() => {
if (Date.now() - lastHeartbeat > 80000) {
clean();
conn.terminate();
}
if (Date.now() - lastHeartbeat > 30000) conn.send('ping');
}, 40000);
conn.on('pong', () => {
lastHeartbeat = Date.now();
});
conn.onmessage = (e) => {
lastHeartbeat = Date.now();
if (e.data === 'pong') return;
if (e.data === 'ping') {
conn.send('pong');
return;
}
let payload;
try {
payload = JSON.parse(e.data.toString());
} catch {
conn.close();
}
try {
h.message?.(payload);
} catch (err) {
logger.error(e);
}
};
await bus.parallel('connection/active', h);
if (conn.readyState === conn.OPEN) {
conn.on('close', clean);
conn.resume();
} else clean();
} catch (e) {
await h.onerror(e);
}
});
return router.disposeLastOp;
}
class NotFoundHandler extends Handler {
prepare() { throw new NotFoundError(this.request.path); }
all() { }
}
export class RouteService extends Service {
private registry = {};
private registrationCount = Counter();
constructor(ctx: Context) {
super(ctx, 'server', true);
ctx.mixin('server', ['Route', 'Connection', 'withHandlerClass']);
}
private register(func: typeof Route | typeof Connection, ...args: Parameters<typeof Route>) {
const HandlerClass = args[2];
const name = HandlerClass.name;
if (!isClass(HandlerClass)) throw new Error('Invalid registration.');
if (this.registrationCount[name] && this.registry[name] !== HandlerClass) {
logger.warn('Route with name %s already exists.', name);
}
this.registry[name] = HandlerClass;
this.registrationCount[name]++;
const res = func(...args);
this.ctx.parallel(`handler/register/${name}`, HandlerClass);
this[Context.current]?.on('dispose', () => {
this.registrationCount[name]--;
if (!this.registrationCount[name]) delete this.registry[name];
res();
});
}
public withHandlerClass(name: string, callback: (HandlerClass: typeof HandlerCommon) => any) {
if (this.registry[name]) callback(this.registry[name]);
this.ctx.on(`handler/register/${name}`, callback);
this[Context.current]?.on('dispose', () => {
this.ctx.off(`handler/register/${name}`, callback);
});
}
// eslint-disable-next-line @typescript-eslint/naming-convention
public Route(...args: Parameters<typeof Route>) {
this.register(Route, ...args);
}
// eslint-disable-next-line @typescript-eslint/naming-convention
public Connection(...args: Parameters<typeof Connection>) {
this.register(Connection, ...args);
}
}
declare module '../context' {
interface Context {
server: RouteService;
}
}
export async function apply(pluginContext: Context) {
pluginContext.provide('server', undefined, true);
pluginContext.server = new RouteService(pluginContext);
app.keys = system.get('session.keys') as unknown as string[];
export async function apply(ctx: Context) {
if (process.env.HYDRO_CLI) return;
const proxyMiddleware = proxy('/fs', {
target: builtinConfig.file.endPoint,
changeOrigin: true,
rewrite: (p) => p.replace('/fs', ''),
ctx.plugin(require('@hydrooj/framework'), {
keys: system.get('session.keys'),
proxy: !!system.get('server.xproxy') || !!system.get('server.xff'),
cors: system.get('server.cors') || '',
upload: system.get('server.upload') || '256m',
port: argv.options.port || system.get('server.port'),
xff: system.get('server.xff'),
xhost: system.get('server.xhost'),
});
const corsAllowHeaders = 'x-requested-with, accept, origin, content-type, upgrade-insecure-requests';
app.use(async (ctx, next) => {
if (ctx.request.headers.origin) {
const host = new URL(ctx.request.headers.origin).host;
if (host !== ctx.request.headers.host && `,${system.get('server.cors')},`.includes(`,${host},`)) {
ctx.set('Access-Control-Allow-Credentials', 'true');
ctx.set('Access-Control-Allow-Origin', ctx.request.headers.origin);
ctx.set('Access-Control-Allow-Headers', corsAllowHeaders);
ctx.set('Vary', 'Origin');
ctx.cors = true;
}
}
if (ctx.request.method.toLowerCase() === 'options') {
ctx.body = 'ok';
return null;
}
for (const key in captureAllRoutes) {
if (ctx.path.startsWith(key)) return captureAllRoutes[key](ctx, next);
}
if (!ctx.path.startsWith('/fs/')) return await next();
if (ctx.request.search.toLowerCase().includes('x-amz-credential')) return await proxyMiddleware(ctx, next);
ctx.request.path = ctx.path = ctx.path.split('/fs')[1];
return await next();
});
app.use(Compress());
for (const addon of [...global.addons].reverse()) {
const dir = resolve(addon, 'public');
if (!fs.existsSync(dir)) continue;
app.use(cache(dir, {
maxAge: argv.options.public ? 0 : 24 * 3600 * 1000,
}));
}
if (process.env.DEV) {
app.use(async (ctx: Koa.Context, next: Function) => {
const startTime = Date.now();
ctx.inject(['server'], ({ server, on }) => {
const proxyMiddleware = proxy('/fs', {
target: builtinConfig.file.endPoint,
changeOrigin: true,
rewrite: (p) => p.replace('/fs', ''),
});
server.addCaptureRoute('/fs/', async (c, next) => {
if (c.request.search.toLowerCase().includes('x-amz-credential')) return await proxyMiddleware(c, next);
c.request.path = c.path = c.path.split('/fs')[1];
return await next();
});
server.addHandlerLayer('init', async (c, next) => {
const init = Date.now();
try {
await next();
} finally {
const endTime = Date.now();
if (!(ctx.nolog || ctx.response.headers.nolog)) {
logger.debug(`${ctx.request.method} /${ctx.domainId || 'system'}${ctx.request.path} \
${ctx.response.status} ${endTime - startTime}ms ${ctx.response.length}`);
const finish = Date.now();
if (finish - init > 5000) {
const method = c.request.method;
const id = await OplogModel.log(c.handler, 'slow_request', { method, processtime: finish - init });
logger.warn(`Slow handler: ID=${id}, `, method, c.path, `${finish - init}ms`);
}
// TODO metrics: calc avg response time
}
});
}
const uploadDir = join(tmpdir(), 'hydro', 'upload', process.env.NODE_APP_INSTANCE || '0');
fs.ensureDirSync(uploadDir);
logger.debug('Using upload dir: %s', uploadDir);
app.use(Body({
multipart: true,
jsonLimit: '8mb',
formLimit: '8mb',
formidable: {
uploadDir,
maxFileSize: parseMemoryMB(system.get('server.upload') || '256m') * 1024 * 1024,
keepExtensions: true,
},
}));
pluginContext.on('app/exit', () => {
fs.emptyDirSync(uploadDir);
});
const layers = [baseLayer, rendererLayer(router, logger), responseLayer(logger), userLayer];
app.use(async (ctx, next) => await next().catch(console.error)).use(domainLayer);
app.use(router.routes()).use(router.allowedMethods());
for (const layer of layers) {
router.use(layer as any);
app.use(layer);
}
app.use((ctx) => handle(ctx, NotFoundHandler, () => true));
wsServer.on('connection', async (socket, request) => {
socket.on('error', (err) => {
logger.warn('Websocket Error: %s', err.message);
try {
socket.close(1003, 'Websocket Error');
} catch (e) { }
});
socket.pause();
const ctx: any = app.createContext(request, {} as any);
await domainLayer(ctx, () => baseLayer(ctx, () => layers[1](ctx, () => userLayer(ctx, () => { }))));
for (const manager of router.wsStack) {
if (manager.accept(socket, request, ctx)) return;
for (const addon of [...global.addons].reverse()) {
const dir = resolve(addon, 'public');
if (!fs.existsSync(dir)) continue;
server.addServerLayer(`${addon}_public`, cache(dir, {
maxAge: argv.options.public ? 0 : 24 * 3600 * 1000,
}));
}
socket.close();
});
const port = system.get('server.port');
pluginContext.on('app/listen', async () => {
await new Promise((r) => {
httpServer.listen(argv.options.port || port, () => {
logger.success('Server listening at: %d', argv.options.port || port);
r(true);
});
server.addServerLayer('domain', domainLayer);
server.addWSLayer('domain', domainLayer);
server.addLayer('base', baseLayer);
server.addLayer('user', userLayer);
server.handlerMixin({
url(name: string, ...kwargsList: Record<string, any>[]) {
if (name === '#') return '#';
let res = '#';
const args: any = {};
const query: any = {};
for (const kwargs of kwargsList) {
for (const key in kwargs) {
if (kwargs[key] instanceof ObjectId) args[key] = kwargs[key].toHexString();
else args[key] = kwargs[key].toString().replace(/\//g, '%2F');
}
for (const key in kwargs.query || {}) {
if (query[key] instanceof ObjectId) query[key] = kwargs.query[key].toHexString();
else query[key] = kwargs.query[key].toString();
}
}
try {
const { anchor } = args;
let withDomainId = args.domainId || false;
const domainId = this.args.domainId;
const host = this.domain?.host;
if (domainId !== 'system' && (
!this.request.host
|| (host instanceof Array
? (!host.includes(this.request.host))
: this.request.host !== host)
)) withDomainId ||= domainId;
res = this.context.router.url.call(this.context.router, name, args, { query }).toString();
if (anchor) res = `${res}#${anchor}`;
if (withDomainId) res = `/d/${withDomainId}${res}`;
} catch (e) {
logger.warn(e.message);
logger.info('%s %o', name, args);
if (!e.message.includes('Expected') || !e.message.includes('to match')) logger.info('%s', e.stack);
}
return res;
},
translate(str: string) {
if (!str) return '';
const lang = this.user?.viewLang || this.session?.viewLang;
const res = lang
? str.toString().translate(lang, ...this.context.acceptsLanguages())
: str.toString().translate(...this.context.acceptsLanguages(), system.get('server.language'));
return res;
},
paginate<T>(cursor: FindCursor<T>, page: number, key: string) {
return paginate(cursor, page, this.ctx.setting.get(`pagination.${key}`));
},
checkPerm(...args: bigint[]) {
if (!this.user.hasPerm(...args)) {
if (this.user.hasPriv(PRIV.PRIV_USER_PROFILE)) throw new PermissionError(...args);
throw new PrivilegeError(PRIV.PRIV_USER_PROFILE);
}
},
checkPriv(...args: number[]) {
if (!this.user.hasPriv(...args)) throw new PrivilegeError(...args);
},
progress(message: string, params: any[]) {
Hydro.model.message.sendInfo(this.user._id, JSON.stringify({ message, params }));
},
async limitRate(
op: string, periodSecs: number, maxOperations: number, withUserId = system.get('limit.by_user'),
) {
if (ignoredLimit.includes(op)) return;
if (this.user && this.user.hasPriv(PRIV.PRIV_UNLIMITED_ACCESS)) return;
const overrideLimit = system.get(`limit.${op}`);
if (overrideLimit) maxOperations = overrideLimit;
let id = this.request.ip;
if (withUserId) id += `@${this.user._id}`;
await opcount.inc(op, id, periodSecs, maxOperations);
},
renderTitle(str: string) {
const name = this.ctx.setting.get('server.name');
if (this.UiContext.extraTitleContent) return `${this.translate(str)} - ${this.UiContext.extraTitleContent} - ${name}`;
return `${this.translate(str)} - ${name}`;
},
});
pluginContext.on('dispose', () => {
httpServer.close();
wsServer.close();
on('handler/create', async (h) => {
h.user = h.context.HydroContext.user as any;
h.domain = h.context.HydroContext.domain as any;
h.translate = h.translate.bind(h);
h.url = h.url.bind(h);
h.ctx = h.ctx.extend({
domain: h.domain,
});
if (!argv.options.benchmark && !h.notUsage) await h.limitRate('global', 5, 100);
h.loginMethods = Object.keys(global.Hydro.module.oauth)
.map((key) => ({
id: key,
icon: global.Hydro.module.oauth[key].icon,
text: global.Hydro.module.oauth[key].text,
}));
if (!h.noCheckPermView && !h.user.hasPriv(PRIV.PRIV_VIEW_ALL_DOMAIN)) h.checkPerm(PERM.PERM_VIEW);
});
on('app/listen', () => {
server.listen();
});
});
}
global.Hydro.service.server = {
...decorators,
Types,
app,
httpServer,
wsServer,
router,
captureAllRoutes,
RouteService,
HandlerCommon,
Handler,
ConnectionHandler,
Route,
Connection,
apply,
};