1
0
silverbullet/server/http_server.ts

385 lines
12 KiB
TypeScript
Raw Normal View History

2022-10-21 15:06:14 +00:00
import { Application, path, Router } from "./deps.ts";
2022-11-26 13:15:38 +00:00
import { Manifest } from "../common/manifest.ts";
import { SpacePrimitives } from "../common/spaces/space_primitives.ts";
import { EndpointHook } from "../plugos/hooks/endpoint.ts";
2022-10-12 09:47:13 +00:00
import { AssetBundle } from "../plugos/asset_bundle/bundle.ts";
2022-11-26 13:15:38 +00:00
import { SpaceSystem } from "./space_system.ts";
import { ensureAndLoadSettings } from "../common/util.ts";
2023-01-13 14:41:29 +00:00
import { base64Decode } from "../plugos/asset_bundle/base64.ts";
export type ServerOptions = {
hostname: string;
port: number;
pagesPath: string;
2022-11-26 13:15:38 +00:00
dbPath: string;
assetBundle: AssetBundle;
2022-12-05 11:14:21 +00:00
user?: string;
pass?: string;
2023-01-13 14:41:29 +00:00
bareMode?: boolean;
};
2022-10-19 07:52:29 +00:00
const staticLastModified = new Date().toUTCString();
export class HttpServer {
app: Application;
2022-11-26 13:15:38 +00:00
systemBoot: SpaceSystem;
private hostname: string;
private port: number;
2022-12-05 11:14:21 +00:00
user?: string;
settings: { [key: string]: any } = {};
abortController?: AbortController;
2023-01-13 14:41:29 +00:00
bareMode: boolean;
constructor(options: ServerOptions) {
this.hostname = options.hostname;
this.port = options.port;
this.app = new Application(); //{ serverConstructor: FlashServer });
this.user = options.user ?? Deno.env.get("SB_USER");
2022-11-26 13:15:38 +00:00
this.systemBoot = new SpaceSystem(
options.assetBundle,
options.pagesPath,
options.dbPath,
);
2023-01-13 14:41:29 +00:00
this.bareMode = options.bareMode || false;
// Second, for loading plug JSON files with absolute or relative (from CWD) paths
2022-11-26 13:15:38 +00:00
this.systemBoot.eventHook.addLocalListener(
"get-plug:file",
async (plugPath: string): Promise<Manifest> => {
const resolvedPath = path.resolve(plugPath);
try {
const manifestJson = await Deno.readTextFile(resolvedPath);
return JSON.parse(manifestJson);
} catch {
throw new Error(
`No such file: ${resolvedPath} or could not parse as JSON`,
);
}
},
);
// Rescan disk every 5s to detect any out-of-process file changes
setInterval(() => {
2022-11-26 13:15:38 +00:00
this.systemBoot.space.updatePageList().catch(console.error);
}, 5000);
2022-11-26 13:15:38 +00:00
// Register the HTTP endpoint hook (with "/_/<plug-name>"" prefix, hardcoded for now)
this.systemBoot.system.addHook(new EndpointHook(this.app, "/_"));
}
async start() {
2022-11-26 13:15:38 +00:00
await this.systemBoot.start();
await this.systemBoot.ensureSpaceIndex();
2023-01-13 14:41:29 +00:00
await ensureAndLoadSettings(this.systemBoot.space, this.bareMode);
2022-12-05 11:14:21 +00:00
2022-12-14 19:32:26 +00:00
this.addPasswordAuth(this.app);
// Serve static files (javascript, css, html)
this.app.use(async ({ request, response }, next) => {
if (request.url.pathname === "/") {
2022-10-21 14:56:46 +00:00
if (request.headers.get("If-Modified-Since") === staticLastModified) {
response.status = 304;
return;
}
response.headers.set("Content-type", "text/html");
2022-11-26 13:15:38 +00:00
response.body = this.systemBoot.assetBundle.readTextFileSync(
"web/index.html",
);
2022-10-19 07:52:29 +00:00
response.headers.set("Last-Modified", staticLastModified);
return;
}
try {
const assetName = `web${request.url.pathname}`;
2022-10-21 14:56:46 +00:00
if (
2022-11-26 13:15:38 +00:00
this.systemBoot.assetBundle.has(assetName) &&
2022-10-21 14:56:46 +00:00
request.headers.get("If-Modified-Since") === staticLastModified
) {
response.status = 304;
return;
}
response.status = 200;
response.headers.set(
"Content-type",
2022-11-26 13:15:38 +00:00
this.systemBoot.assetBundle.getMimeType(assetName),
);
2022-11-26 13:15:38 +00:00
const data = this.systemBoot.assetBundle.readFileSync(
2022-10-12 09:47:13 +00:00
assetName,
);
2022-10-21 14:56:46 +00:00
response.headers.set("Cache-Control", "no-cache");
2022-10-12 09:47:13 +00:00
response.headers.set("Content-length", "" + data.length);
2022-10-19 07:52:29 +00:00
response.headers.set("Last-Modified", staticLastModified);
2022-10-12 09:47:13 +00:00
if (request.method === "GET") {
2022-10-12 09:47:13 +00:00
response.body = data;
}
} catch {
await next();
}
});
// Pages API
2022-11-26 13:15:38 +00:00
const fsRouter = this.buildFsRouter(this.systemBoot.spacePrimitives);
this.app.use(fsRouter.routes());
this.app.use(fsRouter.allowedMethods());
// Plug API
const plugRouter = this.buildPlugRouter();
this.app.use(plugRouter.routes());
this.app.use(plugRouter.allowedMethods());
// Fallback, serve index.html
this.app.use((ctx) => {
ctx.response.headers.set("Content-type", "text/html");
2022-11-26 13:15:38 +00:00
ctx.response.body = this.systemBoot.assetBundle.readTextFileSync(
"web/index.html",
);
});
this.abortController = new AbortController();
2022-12-14 19:32:26 +00:00
this.app.listen({
hostname: this.hostname,
port: this.port,
signal: this.abortController.signal,
})
.catch((e: any) => {
console.log("Server listen error:", e.message);
Deno.exit(1);
});
2022-12-14 19:32:26 +00:00
const visibleHostname = this.hostname === "0.0.0.0"
? "localhost"
: this.hostname;
console.log(
`SilverBullet is now running: http://${visibleHostname}:${this.port}`,
);
2022-11-26 13:15:38 +00:00
}
2022-12-05 11:14:21 +00:00
private addPasswordAuth(app: Application) {
2022-12-22 10:21:12 +00:00
const excludedPaths = [
"/manifest.json",
"/favicon.png",
"/logo.png",
"/.auth",
];
2022-12-05 11:14:21 +00:00
if (this.user) {
2022-12-22 10:21:12 +00:00
const b64User = btoa(this.user);
app.use(async ({ request, response, cookies }, next) => {
if (!excludedPaths.includes(request.url.pathname)) {
2022-12-22 10:21:12 +00:00
const authCookie = await cookies.get("auth");
if (!authCookie || authCookie !== b64User) {
response.redirect(`/.auth?refer=${request.url.pathname}`);
return;
}
}
if (request.url.pathname === "/.auth") {
if (request.method === "GET") {
response.headers.set("Content-type", "text/html");
response.body = this.systemBoot.assetBundle.readTextFileSync(
"web/auth.html",
);
return;
} else if (request.method === "POST") {
const values = await request.body({ type: "form" }).value;
const username = values.get("username"),
password = values.get("password"),
refer = values.get("refer");
if (this.user === `${username}:${password}`) {
await cookies.set("auth", b64User, {
expires: new Date(Date.now() + 1000 * 60 * 60 * 24 * 7), // in a week
sameSite: "strict",
});
response.redirect(refer || "/");
// console.log("All headers", request.headers);
} else {
response.redirect("/.auth?error=1");
}
return;
} else {
response.status = 401;
response.body = "Unauthorized";
2022-12-22 10:21:12 +00:00
return;
}
2022-10-17 18:35:38 +00:00
} else {
// Unauthenticated access to excluded paths
await next();
2022-10-17 18:35:38 +00:00
}
});
}
}
private buildFsRouter(spacePrimitives: SpacePrimitives): Router {
const fsRouter = new Router();
// File list
fsRouter.get("/", async ({ response }) => {
response.headers.set("Content-type", "application/json");
2023-01-13 14:41:29 +00:00
const files = await spacePrimitives.fetchFileList();
response.body = JSON.stringify(files);
2022-10-17 18:35:38 +00:00
});
fsRouter
2022-10-21 14:56:46 +00:00
.get("\/(.+)", async ({ params, response, request }) => {
2022-10-17 18:35:38 +00:00
const name = params[0];
2022-11-26 18:05:55 +00:00
// console.log("Loading file", name);
2022-10-17 18:35:38 +00:00
try {
const attachmentData = await spacePrimitives.readFile(
name,
"arraybuffer",
);
2022-10-21 14:56:46 +00:00
const lastModifiedHeader = new Date(attachmentData.meta.lastModified)
.toUTCString();
if (request.headers.get("If-Modified-Since") === lastModifiedHeader) {
response.status = 304;
return;
}
2022-10-17 18:35:38 +00:00
response.status = 200;
response.headers.set(
"X-Last-Modified",
"" + attachmentData.meta.lastModified,
);
2022-10-21 14:56:46 +00:00
response.headers.set("Cache-Control", "no-cache");
2022-10-17 18:35:38 +00:00
response.headers.set("X-Permission", attachmentData.meta.perm);
2022-10-21 14:56:46 +00:00
response.headers.set(
"Last-Modified",
lastModifiedHeader,
);
2022-10-17 18:35:38 +00:00
response.headers.set("Content-Type", attachmentData.meta.contentType);
response.body = attachmentData.data as ArrayBuffer;
} catch {
// console.error("Error in main router", e);
response.status = 404;
response.body = "";
}
})
.put("\/(.+)", async ({ request, response, params }) => {
const name = params[0];
console.log("Saving file", name);
2023-01-13 14:41:29 +00:00
let body: Uint8Array;
if (
request.headers.get("X-Content-Base64")
) {
const content = await request.body({ type: "text" }).value;
body = base64Decode(content);
} else {
body = await request.body({ type: "bytes" }).value;
}
2022-10-17 18:35:38 +00:00
try {
const meta = await spacePrimitives.writeFile(
name,
"arraybuffer",
2023-01-13 14:41:29 +00:00
body,
2022-10-17 18:35:38 +00:00
);
response.status = 200;
response.headers.set("Content-Type", meta.contentType);
response.headers.set("X-Last-Modified", "" + meta.lastModified);
response.headers.set("X-Content-Length", "" + meta.size);
response.headers.set("X-Permission", meta.perm);
response.body = "OK";
} catch (err) {
response.status = 500;
response.body = "Write failed";
console.error("Pipeline failed", err);
}
})
.options("\/(.+)", async ({ response, params }) => {
const name = params[0];
try {
const meta = await spacePrimitives.getFileMeta(name);
response.status = 200;
response.headers.set("Content-Type", meta.contentType);
response.headers.set("X-Last-Modified", "" + meta.lastModified);
response.headers.set("X-Content-Length", "" + meta.size);
response.headers.set("X-Permission", meta.perm);
} catch {
response.status = 404;
response.body = "File not found";
// console.error("Options failed", err);
}
})
.delete("\/(.+)", async ({ response, params }) => {
const name = params[0];
try {
await spacePrimitives.deleteFile(name);
response.status = 200;
response.body = "OK";
} catch (e: any) {
console.error("Error deleting attachment", e);
response.status = 200;
response.body = e.message;
}
});
return new Router().use("/fs", fsRouter.routes());
}
private buildPlugRouter(): Router {
const plugRouter = new Router();
2022-11-26 13:15:38 +00:00
const system = this.systemBoot.system;
plugRouter.post(
"/:plug/syscall/:name",
async (ctx) => {
const name = ctx.params.name;
const plugName = ctx.params.plug;
const args = await ctx.request.body().value;
2022-11-26 13:15:38 +00:00
const plug = system.loadedPlugs.get(plugName);
if (!plug) {
ctx.response.status = 404;
ctx.response.body = `Plug ${plugName} not found`;
return;
}
try {
2022-11-26 13:15:38 +00:00
const result = await system.syscallWithContext(
{ plug },
name,
args,
);
ctx.response.headers.set("Content-Type", "application/json");
ctx.response.body = JSON.stringify(result);
} catch (e: any) {
2022-10-14 14:49:45 +00:00
console.log("Error", e);
ctx.response.status = 500;
ctx.response.body = e.message;
return;
}
},
);
plugRouter.post(
"/:plug/function/:name",
async (ctx) => {
const name = ctx.params.name;
const plugName = ctx.params.plug;
const args = await ctx.request.body().value;
2022-11-26 13:15:38 +00:00
const plug = system.loadedPlugs.get(plugName);
if (!plug) {
ctx.response.status = 404;
ctx.response.body = `Plug ${plugName} not found`;
return;
}
try {
const result = await plug.invoke(name, args);
ctx.response.headers.set("Content-Type", "application/json");
ctx.response.body = JSON.stringify(result);
} catch (e: any) {
ctx.response.status = 500;
// console.log("Error invoking function", e);
ctx.response.body = e.message;
}
},
);
return new Router().use("/plug", plugRouter.routes());
}
async stop() {
2022-11-26 13:15:38 +00:00
const system = this.systemBoot.system;
if (this.abortController) {
console.log("Stopping");
2022-11-26 13:15:38 +00:00
await system.unloadAll();
console.log("Stopped plugs");
this.abortController.abort();
console.log("stopped server");
}
}
}