mirror of
https://github.com/CommunitySolidServer/CommunitySolidServer.git
synced 2024-10-03 14:55:10 +00:00
feat: Create SetupHttpHandler
This handler allows users to set up servers with a pod and without having to enable public access first
This commit is contained in:
Joachim Van Herwegen
@@ -1,230 +1,27 @@
|
||||
import assert from 'assert';
|
||||
import type { Operation } from '../../../../ldp/operations/Operation';
|
||||
import type { ResourceIdentifier } from '../../../../ldp/representation/ResourceIdentifier';
|
||||
import { getLoggerFor } from '../../../../logging/LogUtil';
|
||||
import type { IdentifierGenerator } from '../../../../pods/generate/IdentifierGenerator';
|
||||
import type { PodManager } from '../../../../pods/PodManager';
|
||||
import type { PodSettings } from '../../../../pods/settings/PodSettings';
|
||||
import { joinUrl } from '../../../../util/PathUtil';
|
||||
import { readJsonStream } from '../../../../util/StreamUtil';
|
||||
import type { OwnershipValidator } from '../../../ownership/OwnershipValidator';
|
||||
import { assertPassword } from '../EmailPasswordUtil';
|
||||
import type { AccountStore } from '../storage/AccountStore';
|
||||
import type { RegistrationManager, RegistrationResponse } from '../util/RegistrationManager';
|
||||
import type { InteractionResponseResult, InteractionHandlerInput } from './InteractionHandler';
|
||||
import { InteractionHandler } from './InteractionHandler';
|
||||
|
||||
const emailRegex = /^[a-zA-Z0-9.!#$%&’*+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*$/u;
|
||||
|
||||
export interface RegistrationHandlerArgs {
|
||||
/**
|
||||
* Used to set the `oidcIssuer` value of newly registered pods.
|
||||
*/
|
||||
baseUrl: string;
|
||||
/**
|
||||
* Appended to the generated pod identifier to create the corresponding WebID.
|
||||
*/
|
||||
webIdSuffix: string;
|
||||
/**
|
||||
* Generates identifiers for new pods.
|
||||
*/
|
||||
identifierGenerator: IdentifierGenerator;
|
||||
/**
|
||||
* Verifies the user is the owner of the WebID they provide.
|
||||
*/
|
||||
ownershipValidator: OwnershipValidator;
|
||||
/**
|
||||
* Stores all the registered account information.
|
||||
*/
|
||||
accountStore: AccountStore;
|
||||
/**
|
||||
* Creates the new pods.
|
||||
*/
|
||||
podManager: PodManager;
|
||||
}
|
||||
|
||||
/**
|
||||
* All the parameters that will be parsed from a request.
|
||||
*/
|
||||
interface ParsedInput {
|
||||
email: string;
|
||||
webId?: string;
|
||||
password?: string;
|
||||
podName?: string;
|
||||
template?: string;
|
||||
createWebId: boolean;
|
||||
register: boolean;
|
||||
createPod: boolean;
|
||||
}
|
||||
|
||||
/**
|
||||
* The results that will be applied to the response template.
|
||||
*/
|
||||
interface RegistrationResponse {
|
||||
email: string;
|
||||
webId?: string;
|
||||
oidcIssuer?: string;
|
||||
podBaseUrl?: string;
|
||||
createWebId: boolean;
|
||||
register: boolean;
|
||||
createPod: boolean;
|
||||
}
|
||||
|
||||
/**
|
||||
* This class handles the 3 potential steps of the registration process:
|
||||
* 1. Generating a new WebID.
|
||||
* 2. Registering a WebID with the IDP.
|
||||
* 3. Creating a new pod for a given WebID.
|
||||
*
|
||||
* All of these steps are optional and will be determined based on the input parameters of a request,
|
||||
* with the following considerations:
|
||||
* * At least one option needs to be chosen.
|
||||
* * In case a new WebID needs to be created, the other 2 steps are obligatory.
|
||||
* * Ownership will be verified when the WebID is provided.
|
||||
* * When registering and creating a pod, the base URL will be used as oidcIssuer value.
|
||||
* Supports registration based on the `RegistrationManager` behaviour.
|
||||
*/
|
||||
export class RegistrationHandler extends InteractionHandler {
|
||||
protected readonly logger = getLoggerFor(this);
|
||||
|
||||
private readonly baseUrl: string;
|
||||
private readonly webIdSuffix: string;
|
||||
private readonly identifierGenerator: IdentifierGenerator;
|
||||
private readonly ownershipValidator: OwnershipValidator;
|
||||
private readonly accountStore: AccountStore;
|
||||
private readonly podManager: PodManager;
|
||||
private readonly registrationManager: RegistrationManager;
|
||||
|
||||
public constructor(args: RegistrationHandlerArgs) {
|
||||
public constructor(registrationManager: RegistrationManager) {
|
||||
super();
|
||||
this.baseUrl = args.baseUrl;
|
||||
this.webIdSuffix = args.webIdSuffix;
|
||||
this.identifierGenerator = args.identifierGenerator;
|
||||
this.ownershipValidator = args.ownershipValidator;
|
||||
this.accountStore = args.accountStore;
|
||||
this.podManager = args.podManager;
|
||||
this.registrationManager = registrationManager;
|
||||
}
|
||||
|
||||
public async handle({ operation }: InteractionHandlerInput):
|
||||
Promise<InteractionResponseResult<RegistrationResponse>> {
|
||||
const result = await this.parseInput(operation);
|
||||
const details = await this.register(result);
|
||||
const data = await readJsonStream(operation.body!.data);
|
||||
const validated = this.registrationManager.validateInput(data, false);
|
||||
const details = await this.registrationManager.register(validated, false);
|
||||
return { type: 'response', details };
|
||||
}
|
||||
|
||||
/**
|
||||
* Does the full registration and pod creation process,
|
||||
* with the steps chosen by the values in the `ParseResult`.
|
||||
*/
|
||||
private async register(result: ParsedInput): Promise<RegistrationResponse> {
|
||||
// This is only used when createWebId and/or createPod are true
|
||||
let podBaseUrl: ResourceIdentifier | undefined;
|
||||
if (result.createWebId || result.createPod) {
|
||||
podBaseUrl = this.identifierGenerator.generate(result.podName!);
|
||||
}
|
||||
|
||||
// Create or verify the WebID
|
||||
if (result.createWebId) {
|
||||
result.webId = joinUrl(podBaseUrl!.path, this.webIdSuffix);
|
||||
} else {
|
||||
await this.ownershipValidator.handleSafe({ webId: result.webId! });
|
||||
}
|
||||
|
||||
// Register the account
|
||||
if (result.register) {
|
||||
await this.accountStore.create(result.email, result.webId!, result.password!);
|
||||
}
|
||||
|
||||
// Create the pod
|
||||
if (result.createPod) {
|
||||
const podSettings: PodSettings = {
|
||||
email: result.email,
|
||||
webId: result.webId!,
|
||||
template: result.template,
|
||||
podBaseUrl: podBaseUrl!.path,
|
||||
};
|
||||
|
||||
// Set the OIDC issuer to our server when registering with the IDP
|
||||
if (result.register) {
|
||||
podSettings.oidcIssuer = this.baseUrl;
|
||||
}
|
||||
|
||||
try {
|
||||
await this.podManager.createPod(podBaseUrl!, podSettings);
|
||||
} catch (error: unknown) {
|
||||
// In case pod creation errors we don't want to keep the account
|
||||
if (result.register) {
|
||||
await this.accountStore.deleteAccount(result.email);
|
||||
}
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
// Verify the account
|
||||
if (result.register) {
|
||||
// This prevents there being a small timeframe where the account can be used before the pod creation is finished.
|
||||
// That timeframe could potentially be used by malicious users.
|
||||
await this.accountStore.verify(result.email);
|
||||
}
|
||||
|
||||
return {
|
||||
webId: result.webId,
|
||||
email: result.email,
|
||||
oidcIssuer: this.baseUrl,
|
||||
podBaseUrl: podBaseUrl?.path,
|
||||
createWebId: result.createWebId,
|
||||
register: result.register,
|
||||
createPod: result.createPod,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Parses the input request into a `ParseResult`.
|
||||
*/
|
||||
private async parseInput(operation: Operation): Promise<ParsedInput> {
|
||||
const parsed = await readJsonStream(operation.body!.data);
|
||||
const prefilled: Record<string, string> = {};
|
||||
for (const [ key, value ] of Object.entries(parsed)) {
|
||||
assert(!Array.isArray(value), `Unexpected multiple values for ${key}.`);
|
||||
prefilled[key] = typeof value === 'string' ? value.trim() : value;
|
||||
}
|
||||
return this.validateInput(prefilled);
|
||||
}
|
||||
|
||||
/**
|
||||
* Converts the raw input date into a `ParseResult`.
|
||||
* Verifies that all the data combinations make sense.
|
||||
*/
|
||||
private validateInput(parsed: NodeJS.Dict<string>): ParsedInput {
|
||||
const { email, password, confirmPassword, webId, podName, register, createPod, createWebId, template } = parsed;
|
||||
|
||||
// Parse email
|
||||
assert(typeof email === 'string' && emailRegex.test(email), 'Please enter a valid e-mail address.');
|
||||
|
||||
const validated: ParsedInput = {
|
||||
email,
|
||||
template,
|
||||
register: Boolean(register) || Boolean(createWebId),
|
||||
createPod: Boolean(createPod) || Boolean(createWebId),
|
||||
createWebId: Boolean(createWebId),
|
||||
};
|
||||
assert(validated.register || validated.createPod, 'Please register for a WebID or create a Pod.');
|
||||
|
||||
// Parse WebID
|
||||
if (!validated.createWebId) {
|
||||
assert(typeof webId === 'string' && /^https?:\/\/[^/]+/u.test(webId), 'Please enter a valid WebID.');
|
||||
validated.webId = webId;
|
||||
}
|
||||
|
||||
// Parse Pod name
|
||||
if (validated.createWebId || validated.createPod) {
|
||||
assert(typeof podName === 'string' && podName.length > 0, 'Please specify a Pod name.');
|
||||
validated.podName = podName;
|
||||
}
|
||||
|
||||
// Parse account
|
||||
if (validated.register) {
|
||||
assertPassword(password, confirmPassword);
|
||||
validated.password = password;
|
||||
}
|
||||
|
||||
return validated;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,245 @@
|
||||
import assert from 'assert';
|
||||
import type { ResourceIdentifier } from '../../../../ldp/representation/ResourceIdentifier';
|
||||
import { getLoggerFor } from '../../../../logging/LogUtil';
|
||||
import type { IdentifierGenerator } from '../../../../pods/generate/IdentifierGenerator';
|
||||
import type { PodManager } from '../../../../pods/PodManager';
|
||||
import type { PodSettings } from '../../../../pods/settings/PodSettings';
|
||||
import { joinUrl } from '../../../../util/PathUtil';
|
||||
import type { OwnershipValidator } from '../../../ownership/OwnershipValidator';
|
||||
import { assertPassword } from '../EmailPasswordUtil';
|
||||
import type { AccountStore } from '../storage/AccountStore';
|
||||
|
||||
export interface RegistrationManagerArgs {
|
||||
/**
|
||||
* Used to set the `oidcIssuer` value of newly registered pods.
|
||||
*/
|
||||
baseUrl: string;
|
||||
/**
|
||||
* Appended to the generated pod identifier to create the corresponding WebID.
|
||||
*/
|
||||
webIdSuffix: string;
|
||||
/**
|
||||
* Generates identifiers for new pods.
|
||||
*/
|
||||
identifierGenerator: IdentifierGenerator;
|
||||
/**
|
||||
* Verifies the user is the owner of the WebID they provide.
|
||||
*/
|
||||
ownershipValidator: OwnershipValidator;
|
||||
/**
|
||||
* Stores all the registered account information.
|
||||
*/
|
||||
accountStore: AccountStore;
|
||||
/**
|
||||
* Creates the new pods.
|
||||
*/
|
||||
podManager: PodManager;
|
||||
}
|
||||
|
||||
/**
|
||||
* The parameters expected for registration.
|
||||
*/
|
||||
export interface RegistrationParams {
|
||||
email: string;
|
||||
webId?: string;
|
||||
password?: string;
|
||||
podName?: string;
|
||||
template?: string;
|
||||
createWebId: boolean;
|
||||
register: boolean;
|
||||
createPod: boolean;
|
||||
rootPod: boolean;
|
||||
}
|
||||
|
||||
/**
|
||||
* The result of a registration action.
|
||||
*/
|
||||
export interface RegistrationResponse {
|
||||
email: string;
|
||||
webId?: string;
|
||||
oidcIssuer?: string;
|
||||
podBaseUrl?: string;
|
||||
createWebId: boolean;
|
||||
register: boolean;
|
||||
createPod: boolean;
|
||||
}
|
||||
|
||||
const emailRegex = /^[a-zA-Z0-9.!#$%&’*+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*$/u;
|
||||
|
||||
/**
|
||||
* Supports IDP registration and pod creation based on input parameters.
|
||||
*
|
||||
* The above behaviour is combined in the two class functions.
|
||||
* `validateInput` will make sure all incoming data is correct and makes sense.
|
||||
* `register` will call all the correct handlers based on the requirements of the validated parameters.
|
||||
*/
|
||||
export class RegistrationManager {
|
||||
protected readonly logger = getLoggerFor(this);
|
||||
|
||||
private readonly baseUrl: string;
|
||||
private readonly webIdSuffix: string;
|
||||
private readonly identifierGenerator: IdentifierGenerator;
|
||||
private readonly ownershipValidator: OwnershipValidator;
|
||||
private readonly accountStore: AccountStore;
|
||||
private readonly podManager: PodManager;
|
||||
|
||||
public constructor(args: RegistrationManagerArgs) {
|
||||
this.baseUrl = args.baseUrl;
|
||||
this.webIdSuffix = args.webIdSuffix;
|
||||
this.identifierGenerator = args.identifierGenerator;
|
||||
this.ownershipValidator = args.ownershipValidator;
|
||||
this.accountStore = args.accountStore;
|
||||
this.podManager = args.podManager;
|
||||
}
|
||||
|
||||
/**
|
||||
* Trims the input if it is a string, returns `undefined` otherwise.
|
||||
*/
|
||||
private trimString(input: unknown): string | undefined {
|
||||
if (typeof input === 'string') {
|
||||
return input.trim();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Makes sure the input conforms to the following requirements when relevant:
|
||||
* * At least one option needs to be chosen.
|
||||
* * In case a new WebID needs to be created, the other 2 steps will be set to true.
|
||||
* * Valid email/WebID/password/podName when required.
|
||||
* * Only create a root pod when allowed.
|
||||
*
|
||||
* @param input - Input parameters for the registration procedure.
|
||||
* @param allowRoot - If creating a pod in the root container should be allowed.
|
||||
*
|
||||
* @returns A cleaned up version of the input parameters.
|
||||
* Only (trimmed) parameters that are relevant to the registration procedure will be retained.
|
||||
*/
|
||||
public validateInput(input: NodeJS.Dict<unknown>, allowRoot = false): RegistrationParams {
|
||||
const {
|
||||
email, password, confirmPassword, webId, podName, register, createPod, createWebId, template, rootPod,
|
||||
} = input;
|
||||
|
||||
// Parse email
|
||||
const trimmedEmail = this.trimString(email);
|
||||
assert(trimmedEmail && emailRegex.test(trimmedEmail), 'Please enter a valid e-mail address.');
|
||||
|
||||
const validated: RegistrationParams = {
|
||||
email: trimmedEmail,
|
||||
register: Boolean(register) || Boolean(createWebId),
|
||||
createPod: Boolean(createPod) || Boolean(createWebId),
|
||||
createWebId: Boolean(createWebId),
|
||||
rootPod: Boolean(rootPod),
|
||||
};
|
||||
assert(validated.register || validated.createPod, 'Please register for a WebID or create a Pod.');
|
||||
assert(allowRoot || !validated.rootPod, 'Creating a root pod is not supported.');
|
||||
|
||||
// Parse WebID
|
||||
if (!validated.createWebId) {
|
||||
const trimmedWebId = this.trimString(webId);
|
||||
assert(trimmedWebId && /^https?:\/\/[^/]+/u.test(trimmedWebId), 'Please enter a valid WebID.');
|
||||
validated.webId = trimmedWebId;
|
||||
}
|
||||
|
||||
// Parse Pod name
|
||||
if (validated.createPod && !validated.rootPod) {
|
||||
const trimmedPodName = this.trimString(podName);
|
||||
assert(trimmedPodName && trimmedPodName.length > 0, 'Please specify a Pod name.');
|
||||
validated.podName = trimmedPodName;
|
||||
}
|
||||
|
||||
// Parse account
|
||||
if (validated.register) {
|
||||
const trimmedPassword = this.trimString(password);
|
||||
const trimmedConfirmPassword = this.trimString(confirmPassword);
|
||||
assertPassword(trimmedPassword, trimmedConfirmPassword);
|
||||
validated.password = trimmedPassword;
|
||||
}
|
||||
|
||||
// Parse template if there is one
|
||||
if (template) {
|
||||
validated.template = this.trimString(template);
|
||||
}
|
||||
|
||||
return validated;
|
||||
}
|
||||
|
||||
/**
|
||||
* Handles the 3 potential steps of the registration process:
|
||||
* 1. Generating a new WebID.
|
||||
* 2. Registering a WebID with the IDP.
|
||||
* 3. Creating a new pod for a given WebID.
|
||||
*
|
||||
* All of these steps are optional and will be determined based on the input parameters.
|
||||
*
|
||||
* This includes the following steps:
|
||||
* * Ownership will be verified when the WebID is provided.
|
||||
* * When registering and creating a pod, the base URL will be used as oidcIssuer value.
|
||||
*/
|
||||
public async register(input: RegistrationParams, allowRoot = false): Promise<RegistrationResponse> {
|
||||
// This is only used when createWebId and/or createPod are true
|
||||
let podBaseUrl: ResourceIdentifier | undefined;
|
||||
if (input.createPod) {
|
||||
if (input.rootPod) {
|
||||
podBaseUrl = { path: this.baseUrl };
|
||||
} else {
|
||||
podBaseUrl = this.identifierGenerator.generate(input.podName!);
|
||||
}
|
||||
}
|
||||
|
||||
// Create or verify the WebID
|
||||
if (input.createWebId) {
|
||||
input.webId = joinUrl(podBaseUrl!.path, this.webIdSuffix);
|
||||
} else {
|
||||
await this.ownershipValidator.handleSafe({ webId: input.webId! });
|
||||
}
|
||||
|
||||
// Register the account
|
||||
if (input.register) {
|
||||
await this.accountStore.create(input.email, input.webId!, input.password!);
|
||||
}
|
||||
|
||||
// Create the pod
|
||||
if (input.createPod) {
|
||||
const podSettings: PodSettings = {
|
||||
email: input.email,
|
||||
webId: input.webId!,
|
||||
template: input.template,
|
||||
podBaseUrl: podBaseUrl!.path,
|
||||
};
|
||||
|
||||
// Set the OIDC issuer to our server when registering with the IDP
|
||||
if (input.register) {
|
||||
podSettings.oidcIssuer = this.baseUrl;
|
||||
}
|
||||
|
||||
try {
|
||||
// Only allow overwrite for root pods
|
||||
await this.podManager.createPod(podBaseUrl!, podSettings, allowRoot);
|
||||
} catch (error: unknown) {
|
||||
// In case pod creation errors we don't want to keep the account
|
||||
if (input.register) {
|
||||
await this.accountStore.deleteAccount(input.email);
|
||||
}
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
// Verify the account
|
||||
if (input.register) {
|
||||
// This prevents there being a small timeframe where the account can be used before the pod creation is finished.
|
||||
// That timeframe could potentially be used by malicious users.
|
||||
await this.accountStore.verify(input.email);
|
||||
}
|
||||
|
||||
return {
|
||||
webId: input.webId,
|
||||
email: input.email,
|
||||
oidcIssuer: this.baseUrl,
|
||||
podBaseUrl: podBaseUrl?.path,
|
||||
createWebId: input.createWebId,
|
||||
register: input.register,
|
||||
createPod: input.createPod,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
@@ -38,6 +38,9 @@ export * from './identity/interaction/email-password/handler/ResetPasswordHandle
|
||||
export * from './identity/interaction/email-password/storage/AccountStore';
|
||||
export * from './identity/interaction/email-password/storage/BaseAccountStore';
|
||||
|
||||
// Identity/Interaction/Email-Password/Util
|
||||
export * from './identity/interaction/email-password/util/RegistrationManager';
|
||||
|
||||
// Identity/Interaction/Email-Password
|
||||
export * from './identity/interaction/email-password/EmailPasswordUtil';
|
||||
|
||||
@@ -70,6 +73,9 @@ export * from './identity/IdentityProviderHttpHandler';
|
||||
export * from './init/final/Finalizable';
|
||||
export * from './init/final/ParallelFinalizer';
|
||||
|
||||
// Init/Setup
|
||||
export * from './init/setup/SetupHttpHandler';
|
||||
|
||||
// Init
|
||||
export * from './init/App';
|
||||
export * from './init/AppRunner';
|
||||
|
||||
206
src/init/setup/SetupHttpHandler.ts
Normal file
206
src/init/setup/SetupHttpHandler.ts
Normal file
@@ -0,0 +1,206 @@
|
||||
import type { RegistrationParams,
|
||||
RegistrationManager } from '../../identity/interaction/email-password/util/RegistrationManager';
|
||||
import type { ErrorHandler } from '../../ldp/http/ErrorHandler';
|
||||
import type { RequestParser } from '../../ldp/http/RequestParser';
|
||||
import { ResponseDescription } from '../../ldp/http/response/ResponseDescription';
|
||||
import type { ResponseWriter } from '../../ldp/http/ResponseWriter';
|
||||
import type { Operation } from '../../ldp/operations/Operation';
|
||||
import { BasicRepresentation } from '../../ldp/representation/BasicRepresentation';
|
||||
import { getLoggerFor } from '../../logging/LogUtil';
|
||||
import type { BaseHttpHandlerArgs } from '../../server/BaseHttpHandler';
|
||||
import { BaseHttpHandler } from '../../server/BaseHttpHandler';
|
||||
import type { RepresentationConverter } from '../../storage/conversion/RepresentationConverter';
|
||||
import type { KeyValueStorage } from '../../storage/keyvalue/KeyValueStorage';
|
||||
import { APPLICATION_JSON, TEXT_HTML } from '../../util/ContentTypes';
|
||||
import { createErrorMessage } from '../../util/errors/ErrorUtil';
|
||||
import { HttpError } from '../../util/errors/HttpError';
|
||||
import { InternalServerError } from '../../util/errors/InternalServerError';
|
||||
import { MethodNotAllowedHttpError } from '../../util/errors/MethodNotAllowedHttpError';
|
||||
import { NotImplementedHttpError } from '../../util/errors/NotImplementedHttpError';
|
||||
import { addTemplateMetadata } from '../../util/ResourceUtil';
|
||||
import { readJsonStream } from '../../util/StreamUtil';
|
||||
import type { Initializer } from '../Initializer';
|
||||
|
||||
/**
|
||||
* Input parameters expected in calls to the handler.
|
||||
* Will be sent to the RegistrationManager for validation and registration.
|
||||
* The reason this is a flat object and does not have a specific field for all the registration parameters
|
||||
* is so we can also support form data.
|
||||
*/
|
||||
export interface SetupInput extends Record<string, any>{
|
||||
/**
|
||||
* Indicates if the initializer should be executed. Ignored if `registration` is true.
|
||||
*/
|
||||
initialize?: boolean;
|
||||
/**
|
||||
* Indicates if the registration procedure should be done for IDP registration and/or pod provisioning.
|
||||
*/
|
||||
registration?: boolean;
|
||||
}
|
||||
|
||||
export interface SetupHttpHandlerArgs extends BaseHttpHandlerArgs {
|
||||
// BaseHttpHandler args
|
||||
requestParser: RequestParser;
|
||||
errorHandler: ErrorHandler;
|
||||
responseWriter: ResponseWriter;
|
||||
|
||||
/**
|
||||
* Used for registering a pod during setup.
|
||||
*/
|
||||
registrationManager?: RegistrationManager;
|
||||
/**
|
||||
* Initializer to call in case no registration procedure needs to happen.
|
||||
* This Initializer should make sure the necessary resources are there so the server can work correctly.
|
||||
*/
|
||||
initializer?: Initializer;
|
||||
/**
|
||||
* Used for content negotiation.
|
||||
*/
|
||||
converter: RepresentationConverter;
|
||||
/**
|
||||
* Key that is used to store the boolean in the storage indicating setup is finished.
|
||||
*/
|
||||
storageKey: string;
|
||||
/**
|
||||
* Used to store setup status.
|
||||
*/
|
||||
storage: KeyValueStorage<string, boolean>;
|
||||
/**
|
||||
* Template to use for GET requests.
|
||||
*/
|
||||
viewTemplate: string;
|
||||
/**
|
||||
* Template to show when setup was completed successfully.
|
||||
*/
|
||||
responseTemplate: string;
|
||||
}
|
||||
|
||||
/**
|
||||
* Handles the initial setup of a server.
|
||||
* Will capture all requests until setup is finished,
|
||||
* this to prevent accidentally running unsafe servers.
|
||||
*
|
||||
* GET requests will return the view template which should contain the setup information for the user.
|
||||
* POST requests will run an initializer and/or perform a registration step, both optional.
|
||||
* After successfully completing a POST request this handler will disable itself and become unreachable.
|
||||
* All other methods will be rejected.
|
||||
*/
|
||||
export class SetupHttpHandler extends BaseHttpHandler {
|
||||
protected readonly logger = getLoggerFor(this);
|
||||
|
||||
private readonly registrationManager?: RegistrationManager;
|
||||
private readonly initializer?: Initializer;
|
||||
private readonly converter: RepresentationConverter;
|
||||
private readonly storageKey: string;
|
||||
private readonly storage: KeyValueStorage<string, boolean>;
|
||||
private readonly viewTemplate: string;
|
||||
private readonly responseTemplate: string;
|
||||
|
||||
private finished: boolean;
|
||||
|
||||
public constructor(args: SetupHttpHandlerArgs) {
|
||||
super(args);
|
||||
this.finished = false;
|
||||
|
||||
this.registrationManager = args.registrationManager;
|
||||
this.initializer = args.initializer;
|
||||
this.converter = args.converter;
|
||||
this.storageKey = args.storageKey;
|
||||
this.storage = args.storage;
|
||||
this.viewTemplate = args.viewTemplate;
|
||||
this.responseTemplate = args.responseTemplate;
|
||||
}
|
||||
|
||||
public async handleOperation(operation: Operation): Promise<ResponseDescription> {
|
||||
let json: Record<string, any>;
|
||||
let template: string;
|
||||
let success = false;
|
||||
let statusCode = 200;
|
||||
try {
|
||||
({ json, template } = await this.getJsonResult(operation));
|
||||
success = true;
|
||||
} catch (err: unknown) {
|
||||
// We want to show the errors on the original page in case of HTML interactions, so we can't just throw them here
|
||||
const error = HttpError.isInstance(err) ? err : new InternalServerError(createErrorMessage(err));
|
||||
({ statusCode } = error);
|
||||
this.logger.warn(error.message);
|
||||
const response = await this.errorHandler.handleSafe({ error, preferences: { type: { [APPLICATION_JSON]: 1 }}});
|
||||
json = await readJsonStream(response.data!);
|
||||
template = this.viewTemplate;
|
||||
}
|
||||
|
||||
// Convert the response JSON to the required format
|
||||
const representation = new BasicRepresentation(JSON.stringify(json), operation.target, APPLICATION_JSON);
|
||||
addTemplateMetadata(representation.metadata, template, TEXT_HTML);
|
||||
const result = await this.converter.handleSafe(
|
||||
{ representation, identifier: operation.target, preferences: operation.preferences },
|
||||
);
|
||||
|
||||
// Make sure this setup handler is never used again after a successful POST request
|
||||
if (success && operation.method === 'POST') {
|
||||
this.finished = true;
|
||||
await this.storage.set(this.storageKey, true);
|
||||
}
|
||||
|
||||
return new ResponseDescription(statusCode, result.metadata, result.data);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a JSON object representing the result of executing the given operation,
|
||||
* together with the template it should be applied to.
|
||||
*/
|
||||
private async getJsonResult(operation: Operation): Promise<{ json: Record<string, any>; template: string }> {
|
||||
if (operation.method === 'GET') {
|
||||
// Return the initial setup page
|
||||
return { json: {}, template: this.viewTemplate };
|
||||
}
|
||||
if (operation.method !== 'POST') {
|
||||
throw new MethodNotAllowedHttpError();
|
||||
}
|
||||
|
||||
// Registration manager expects JSON data
|
||||
let json: SetupInput = {};
|
||||
if (operation.body) {
|
||||
const args = {
|
||||
representation: operation.body,
|
||||
preferences: { type: { [APPLICATION_JSON]: 1 }},
|
||||
identifier: operation.target,
|
||||
};
|
||||
const converted = await this.converter.handleSafe(args);
|
||||
json = await readJsonStream(converted.data);
|
||||
this.logger.debug(`Input JSON: ${JSON.stringify(json)}`);
|
||||
}
|
||||
|
||||
// We want to initialize after the input has been validated, but before (potentially) writing a pod
|
||||
// since that might overwrite the initializer result
|
||||
if (json.initialize && !json.registration) {
|
||||
if (!this.initializer) {
|
||||
throw new NotImplementedHttpError('This server is not configured with a setup initializer.');
|
||||
}
|
||||
await this.initializer.handleSafe();
|
||||
}
|
||||
|
||||
let output: Record<string, any> = {};
|
||||
// We only call the RegistrationManager when getting registration input.
|
||||
// This way it is also possible to set up a server without requiring registration parameters.
|
||||
let validated: RegistrationParams | undefined;
|
||||
if (json.registration) {
|
||||
if (!this.registrationManager) {
|
||||
throw new NotImplementedHttpError('This server is not configured to support registration during setup.');
|
||||
}
|
||||
// Validate the input JSON
|
||||
validated = this.registrationManager.validateInput(json, true);
|
||||
this.logger.debug(`Validated input: ${JSON.stringify(validated)}`);
|
||||
|
||||
// Register and/or create a pod as requested. Potentially does nothing if all booleans are false.
|
||||
output = await this.registrationManager.register(validated, true);
|
||||
}
|
||||
|
||||
// Add extra setup metadata
|
||||
output.initialize = Boolean(json.initialize);
|
||||
output.registration = Boolean(json.registration);
|
||||
this.logger.debug(`Output: ${JSON.stringify(output)}`);
|
||||
|
||||
return { json: output, template: this.responseTemplate };
|
||||
}
|
||||
}
|
||||
@@ -26,9 +26,9 @@ export class GeneratedPodManager implements PodManager {
|
||||
* Creates a new pod, pre-populating it with the resources created by the data generator.
|
||||
* Will throw an error if the given identifier already has a resource.
|
||||
*/
|
||||
public async createPod(identifier: ResourceIdentifier, settings: PodSettings): Promise<void> {
|
||||
public async createPod(identifier: ResourceIdentifier, settings: PodSettings, overwrite: boolean): Promise<void> {
|
||||
this.logger.info(`Creating pod ${identifier.path}`);
|
||||
if (await this.store.resourceExists(identifier)) {
|
||||
if (!overwrite && await this.store.resourceExists(identifier)) {
|
||||
throw new ConflictHttpError(`There already is a resource at ${identifier.path}`);
|
||||
}
|
||||
|
||||
|
||||
@@ -10,6 +10,7 @@ export interface PodManager {
|
||||
* Creates a pod for the given settings.
|
||||
* @param identifier - Root identifier indicating where the pod should be created.
|
||||
* @param settings - Settings describing the pod.
|
||||
* @param overwrite - If the creation should proceed if there already is a resource there.
|
||||
*/
|
||||
createPod: (identifier: ResourceIdentifier, settings: PodSettings) => Promise<void>;
|
||||
createPod: (identifier: ResourceIdentifier, settings: PodSettings, overwrite: boolean) => Promise<void>;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user