mirror of
https://github.com/filecoin-project/slate.git
synced 2024-09-11 13:57:37 +03:00
423 lines
12 KiB
JavaScript
423 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';
|
|
|
|
// TODO(jim): Support multiple desktop applications.
|
|
let client = null;
|
|
let state = null;
|
|
|
|
const production = process.env.NODE_ENV === 'production';
|
|
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, 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,
|
|
};
|
|
|
|
if (!production) {
|
|
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.
|
|
if (!FS.existsSync(`./.data`)) {
|
|
FS.mkdirSync(`./.data`, { recursive: true });
|
|
}
|
|
|
|
// NOTE(jim): This will create a token for authentication with powergate.
|
|
// TODO(jim): Roll this up into Postgres instead.
|
|
if (!FS.existsSync('./.data/powergate-token')) {
|
|
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('./.data/powergate-token', state.token);
|
|
}
|
|
} else {
|
|
state.token = FS.readFileSync('./.data/powergate-token', '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.
|
|
if (!FS.existsSync('./.data/library.json')) {
|
|
const librarySchema = {
|
|
library: [
|
|
{
|
|
...Utilities.createFolder({ id: Constants.FILE_STORAGE_URL }),
|
|
file: 'Files',
|
|
name: 'Files',
|
|
},
|
|
],
|
|
};
|
|
|
|
FS.writeFileSync('./.data/library.json', JSON.stringify(librarySchema));
|
|
state.library = librarySchema.library;
|
|
} else {
|
|
const parsedLibrary = FS.readFileSync('./.data/library.json', 'utf8');
|
|
state.library = JSON.parse(parsedLibrary).library;
|
|
}
|
|
|
|
// NOTE(jim): Local settings retrieval or creation
|
|
// TODO(jim): Move this to postgres later.
|
|
if (!FS.existsSync('./.data/local-settings.json')) {
|
|
const localSettingsSchema = {
|
|
local: {
|
|
photo: null,
|
|
name: `node-${uuid()}`,
|
|
settings_deals_auto_approve: false,
|
|
},
|
|
};
|
|
|
|
FS.writeFileSync(
|
|
'./.data/local-settings.json',
|
|
JSON.stringify(localSettingsSchema)
|
|
);
|
|
state.local = localSettingsSchema.local;
|
|
} else {
|
|
const parsedLocal = FS.readFileSync(
|
|
'./data/local-settings.json',
|
|
'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();
|
|
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 (production) {
|
|
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 (!production) {
|
|
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) {
|
|
FS.writeFileSync(
|
|
'./.data/library.json',
|
|
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) {
|
|
FS.writeFileSync(
|
|
'./.data/library.json',
|
|
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 = `/static/system/${newName}`;
|
|
FS.writeFileSync(
|
|
'./.data/local-settings.json',
|
|
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 };
|
|
|
|
FS.writeFileSync(
|
|
'./.data/local-settings.json',
|
|
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 (!state.token) {
|
|
return res.redirect('/system');
|
|
}
|
|
|
|
return app.render(req, res, '/', {
|
|
production,
|
|
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 (!production) {
|
|
await setIntervalViewerUpdatesUnsafe();
|
|
}
|
|
});
|
|
});
|