slate/server.js
2020-07-10 09:48:37 -07:00

439 lines
12 KiB
JavaScript

import * as Middleware from "./common/middleware";
import * as Strings from "./common/strings";
import * as Utilities from "./node_common/utilities";
import * as Constants from "./node_common/constants";
import { createPow, ffs } from "@textile/powergate-client";
// NOTE(jim):
// https://github.com/textileio/js-powergate-client
const PowerGate = createPow({ host: Constants.POWERGATE_HOST });
import FS from "fs-extra";
import WebSocketServer from "ws";
import express from "express";
import formidable from "formidable";
import next from "next";
import bodyParser from "body-parser";
import compression from "compression";
import { v4 as uuid } from "uuid";
import path from "path";
// TODO(jim): Support multiple desktop applications.
let client = null;
let state = null;
const production =
process.env.NODE_ENV === "production" || process.env.NODE_ENV === "www";
const productionWeb = process.env.NODE_ENV === "www";
const port = process.env.PORT || 1337;
const wsPort = process.env.WS_PORT || 2448;
const resetData = process.env.npm_config_reset_data;
const app = next({ dev: !production, dir: __dirname, quiet: false });
const nextRequestHandler = app.getRequestHandler();
const setIntervalViewerUpdatesUnsafe = async () => {
if (client) {
try {
console.log("[ prototype ] polling: new viewer state.");
state = await Utilities.emitState({
state,
client,
PG: PowerGate,
});
console.log("[ prototype ] polling: new library state.");
state = await Utilities.refreshLibrary({
state,
PG: PowerGate,
FFS: ffs,
});
} catch (e) {
console.log(e);
}
}
setTimeout(setIntervalViewerUpdatesUnsafe, Constants.POLLING_RATE);
};
app.prepare().then(async () => {
console.log("[ prototype ] initializing ");
state = {
production,
port,
wsPort,
token: null,
library: null,
status: null,
messageList: null,
peersList: null,
addrsList: null,
info: null,
local: null,
};
try {
// NOTE(daniel): Wipe all of the local data when --reset-data flag is added to npm run dev.
if (resetData) {
await Utilities.resetFileSystem();
}
const updates = await Utilities.refresh({ PG: PowerGate });
state = await Utilities.updateStateData(state, updates);
console.log("[ prototype ] updated without token");
// NOTE(jim): This is a configuration folder with all of the client tokens.
// TODO(jim): Unnecessary if we use a local and remote postgres.
const dirnameData = path.join(__dirname, "/.data");
if (!FS.existsSync(dirnameData)) {
FS.mkdirSync(dirnameData, { recursive: true });
}
// NOTE(jim): This will create a token for authentication with powergate.
// TODO(jim): Roll this up into Postgres instead.
const dirnamePowergate = path.join(__dirname, "/.data/powergate-token");
if (!FS.existsSync(dirnamePowergate)) {
const FFS = await PowerGate.ffs.create();
state.token = FFS.token ? FFS.token : null;
// NOTE(jim): Write a new token file.
if (state.token) {
FS.writeFileSync(dirnamePowergate, state.token);
}
} else {
state.token = FS.readFileSync(dirnamePowergate, "utf8");
}
if (state.token) {
console.log("[ prototype ] powergate token:", state.token);
PowerGate.setToken(state.token);
}
const tokenUpdates = await Utilities.refreshWithToken({
PG: PowerGate,
});
state = await Utilities.updateStateData(state, tokenUpdates);
console.log("[ prototype ] updated with token");
// NOTE(jim): Local library retrieval or creation
// TODO(jim): Needs to support nested folders in the future.
// TODO(jim): May consider a move to buckets.
const dirnameLibrary = path.join(__dirname, "/.data/library.json");
if (!FS.existsSync(dirnameLibrary)) {
const librarySchema = {
library: [
{
...Utilities.createFolder({ id: Constants.FILE_STORAGE_URL }),
file: "Files",
name: "Files",
},
],
};
FS.writeFileSync(dirnameLibrary, JSON.stringify(librarySchema));
state.library = librarySchema.library;
} else {
const parsedLibrary = FS.readFileSync(dirnameLibrary, "utf8");
state.library = JSON.parse(parsedLibrary).library;
}
// NOTE(jim): Local settings retrieval or creation
// TODO(jim): Move this to postgres later.
const dirnameLocalSettings = path.join(
__dirname,
"/.data/local-settings.json"
);
if (!FS.existsSync(dirnameLocalSettings)) {
const localSettingsSchema = {
local: {
photo: null,
name: `node-${uuid()}`,
settings_deals_auto_approve: false,
},
};
FS.writeFileSync(
dirnameLocalSettings,
JSON.stringify(localSettingsSchema)
);
state.local = localSettingsSchema.local;
} else {
const parsedLocal = FS.readFileSync(dirnameLocalSettings, "utf8");
state.local = JSON.parse(parsedLocal).local;
}
} catch (e) {
console.log(e);
console.log('[ prototype ] "/" -- WILL REDIRECT TO /SYSTEM ');
console.log(
"[ prototype ] SLATE WILL NOT RUN LOCALLY UNTIL YOU HAVE "
);
console.log("[ prototype ] PROPERLY CONFIGURED POWERGATE AND ");
console.log(
"[ prototype ] CONNECTED TO THE FILECOIN NETWORK (DEVNET/TESTNET) "
);
}
const server = express();
// TODO(jim): Temporarily disable web sockets for web production
// since we have no web version of Slate yet.
if (!productionWeb) {
const WSS = new WebSocketServer.Server({ port: wsPort });
WSS.on("connection", (s) => {
// TODO(jim): Suppport more than one client.
client = s;
s.on("close", function() {
s.send(JSON.stringify({ action: null, data: "closed" }));
});
s.send(JSON.stringify({ action: null, data: "connected" }));
});
}
if (productionWeb) {
server.use(compression());
}
server.use(Middleware.CORS);
server.use("/public", express.static("public"));
server.use(bodyParser.json());
server.use(
bodyParser.urlencoded({
extended: false,
})
);
server.post("/_/viewer", async (req, res) => {
let data = state;
if (!productionWeb) {
const updates = await Utilities.refresh({ PG: PowerGate });
const updatesWithToken = await Utilities.refreshWithToken({
PG: PowerGate,
});
data = await Utilities.updateStateData(data, {
...updates,
...updatesWithToken,
});
}
return res.status(200).send({ success: true, data });
});
server.post("/_/deals/storage", async (req, res) => {
if (Strings.isEmpty(req.body.src)) {
return res.status(500).send({ success: false });
}
const localPath = `.${req.body.src}`;
const buffer = FS.readFileSync(localPath);
const { cid } = await PowerGate.ffs.addToHot(buffer);
const { jobId } = await PowerGate.ffs.pushConfig(cid);
// TODO(jim): Refactor this so we repeat this less often.
let write = false;
for (let i = 0; i < state.library.length; i++) {
for (let j = 0; j < state.library[i].children.length; j++) {
if (localPath === state.library[i].children[j].id) {
state.library[i].children[j].job_id = jobId;
state.library[i].children[j].cid = cid;
state.library[i].children[j].storage_status = 1;
write = true;
}
}
}
// NOTE(jim): Writes the updated deal state.
if (write) {
const dirnameLibrary = path.join(__dirname, "/.data/library.json");
FS.writeFileSync(
dirnameLibrary,
JSON.stringify({ library: state.library })
);
}
state = await Utilities.emitState({ state, client, PG: PowerGate });
return res.status(200).send({ success: true, cid, jobId });
});
server.post("/_/storage/:file", async (req, res) => {
const form = formidable({
multiples: true,
uploadDir: Constants.FILE_STORAGE_URL,
});
form.parse(req, async (error, fields, files) => {
if (error) {
return res.status(500).send({ error });
} else {
// TODO(jim): Need to support other file types.
if (!files.image) {
console.error("[ prototype ] File type unspported", files);
return res
.status(500)
.send({ error: "File type unsupported", files });
}
const newPath = form.uploadDir + req.params.file;
FS.rename(files.image.path, newPath, function(err) {});
const localFile = Utilities.createFile({
id: newPath,
data: files.image,
});
// TODO(jim): Messy, refactor.
let pushed = false;
for (let i = 0; i < state.library.length; i++) {
if (!pushed) {
state.library[i].children.push(localFile);
pushed = true;
break;
}
}
// NOTE(jim): Writes the added file.
if (pushed) {
const dirnameLibrary = path.join(__dirname, "/.data/library.json");
FS.writeFileSync(
dirnameLibrary,
JSON.stringify({ library: state.library })
);
}
state = await Utilities.emitState({
state,
client,
PG: PowerGate,
});
return res.status(200).send({ success: true, file: localFile });
}
});
});
server.post("/_/upload/avatar", async (req, res) => {
const form = formidable({
multiples: true,
uploadDir: Constants.AVATAR_STORAGE_URL,
});
form.parse(req, async (error, fields, files) => {
if (error) {
return res.status(500).send({ error });
} else {
const newName = `avatar-${uuid()}.png`;
const newPath = form.uploadDir + newName;
FS.rename(files.image.path, newPath, function(err) {});
// NOTE(jim): updates avatar photo.
state.local.photo = __dirname + `/static/system/${newName}`;
const dirnameLocalSettings = path.join(
__dirname,
"/.data/local-settings.json"
);
FS.writeFileSync(
dirnameLocalSettings,
JSON.stringify({ local: { ...state.local } })
);
state = await Utilities.emitState({
state,
client,
PG: PowerGate,
});
return res.status(200).send({ success: true });
}
});
});
server.post("/_/settings", async (req, res) => {
let data;
try {
data = await PowerGate.ffs.setDefaultConfig(req.body.config);
} catch (e) {
return res.status(500).send({ error: e.message });
}
state = await Utilities.emitState({ state, client, PG: PowerGate });
return res.status(200).send({ success: true, data });
});
server.post("/_/local-settings", async (req, res) => {
state.local = { ...state.local, ...req.body.local };
const dirnameLocalSettings = path.join(
__dirname,
"/.data/local-settings.json"
);
FS.writeFileSync(
dirnameLocalSettings,
JSON.stringify({ local: { ...state.local } })
);
state = await Utilities.emitState({ state, client, PG: PowerGate });
return res.status(200).send({ success: true });
});
server.post("/_/wallet/create", async (req, res) => {
let data;
try {
data = await PowerGate.ffs.newAddr(
req.body.name,
req.body.type,
req.body.makeDefault
);
} catch (e) {
return res.status(500).send({ error: e.message });
}
state = await Utilities.emitState({ state, client, PG: PowerGate });
return res.status(200).send({ success: true, data });
});
server.post("/_/wallet/send", async (req, res) => {
let data;
try {
data = await PowerGate.ffs.sendFil(
req.body.source,
req.body.target,
req.body.amount
);
} catch (e) {
return res.status(500).send({ error: e.message });
}
state = await Utilities.emitState({ state, client, PG: PowerGate });
return res
.status(200)
.send({ success: true, data: { ...data, ...req.body } });
});
server.get("/", async (req, res) => {
if (productionWeb) {
return res.redirect("/system");
}
return app.render(req, res, "/", {
wsPort,
});
});
server.get("*", async (req, res) => {
return nextRequestHandler(req, res, req.url);
});
server.listen(port, async (err) => {
if (err) {
throw err;
}
console.log(`[ prototype ] client: http://localhost:${port}`);
console.log(`[ prototype ] constants:`, Constants);
if (!productionWeb) {
await setIntervalViewerUpdatesUnsafe();
}
});
});