323 lines
8.8 KiB
JavaScript
323 lines
8.8 KiB
JavaScript
const express = require('express');
|
|
const router = express.Router();
|
|
const { check, validationResult } = require('express-validator/check')
|
|
const { matchedData } = require('express-validator/filter')
|
|
const _ = require('lodash');
|
|
const WebtorrentHybrid = require('webtorrent-hybrid')
|
|
|
|
const client = require('./server.js');
|
|
const funcs = require('./public/js/funcs')
|
|
|
|
var path = require('path')
|
|
var fs = require('fs');
|
|
|
|
var Tracker = require('bittorrent-tracker')
|
|
var magnet = require('magnet-uri')
|
|
|
|
//const JSON = require('circular-json');
|
|
|
|
router.get('/', (req, res)=>{
|
|
res.render('index.ejs', {
|
|
data: {},
|
|
errors: {},
|
|
title: 'Welcome!'
|
|
})
|
|
})
|
|
|
|
router.get('/seed', (req, res)=>{
|
|
res.render('seed.ejs', {
|
|
data: {},
|
|
errors: {},
|
|
title: 'Seed!'
|
|
})
|
|
})
|
|
|
|
router.get('/download', (req, res)=>{
|
|
res.render('download.ejs', {
|
|
data: {},
|
|
errors: {},
|
|
title: 'Download!'
|
|
})
|
|
})
|
|
|
|
router.get('/download-magnetic-uri', (req, res)=>{
|
|
res.render('magnetic.ejs', {
|
|
data: {},
|
|
errors: {},
|
|
title: 'Download Magnetic URI!'
|
|
})
|
|
})
|
|
|
|
router.post('/download-magnetic-uri', (req, res)=>{
|
|
|
|
let params = _.pick(req.body, ['job', 'torrentId'])
|
|
|
|
if (params.job != 'download-magnetic-uri') {
|
|
return
|
|
}
|
|
|
|
var client = new WebtorrentHybrid()
|
|
|
|
client.on('error', function (err) {
|
|
console.error('ERROR: ' + err.message)
|
|
})
|
|
|
|
var torrentId = params.torrentId
|
|
|
|
if (_.trim(torrentId) == '') {
|
|
console.error("Empty torrent id");
|
|
return;
|
|
}
|
|
|
|
client.add(torrentId, function (torrent) {
|
|
|
|
//torrent.on('wire', (wire)=>{
|
|
// console.log(wire);
|
|
// console.log(wire._readableState.pipes.remoteAddress);
|
|
// console.log(wire._readableState.pipes.remoteFamily);
|
|
// console.log(wire._readableState.pipes.remotePort);
|
|
// console.log(wire._readableState.pipes.localAddress);
|
|
// console.log(wire._readableState.pipes.localPort);
|
|
|
|
//console.log(wire._readableState.pipes._pc);
|
|
|
|
|
|
|
|
// var id = wire.peerId.toString()
|
|
// var addr = wire.remoteAddress
|
|
// console.log(id);
|
|
// console.log(addr);
|
|
//})
|
|
|
|
var files = torrent.files
|
|
var length = files.length
|
|
// Stream each file to the disk
|
|
files.forEach(function (file) {
|
|
//console.log(file._torrent.path);
|
|
|
|
var source = file.createReadStream()
|
|
var destination = fs.createWriteStream(`files/${file.name}`)
|
|
|
|
let fullpath = path.resolve(`files/${file.name}`)
|
|
|
|
source.on('end', function () {
|
|
console.log('file:\t\t', file.name)
|
|
|
|
res.json({file:file.name, location:fullpath})
|
|
|
|
// close after all files are saved
|
|
if (!--length) process.exit()
|
|
}).pipe(destination)
|
|
|
|
})
|
|
|
|
})
|
|
|
|
})
|
|
|
|
router.get('/send-to-blockchain', (req, res)=>{
|
|
res.render('to_flo', {
|
|
data: {},
|
|
errors: {},
|
|
title: 'Send the torrent to flo'
|
|
})
|
|
})
|
|
|
|
router.post('/send-to-blockchain', [
|
|
check('job')
|
|
.isLength({min:1})
|
|
.withMessage('Invalid job!')
|
|
.trim(),
|
|
check('magtor')
|
|
.isLength({min:1})
|
|
.withMessage('Invalid magnetic uri!')
|
|
.trim()
|
|
],(req,res)=>{
|
|
|
|
const errors = validationResult(req)
|
|
console.log(errors.mapped());
|
|
|
|
if(!errors.isEmpty()) {
|
|
return res.render('send-to-blockchain', {
|
|
data: req.body,
|
|
errors: errors.mapped(),
|
|
title: 'Please correct your errors'
|
|
})
|
|
}
|
|
|
|
let params = _.pick(req.body, ['job', 'magtor'])
|
|
|
|
if (typeof params.job == undefined || params.job!='magtor') {
|
|
console.log("Unknown request");
|
|
return;
|
|
}
|
|
|
|
let magnetic_uri = params.magtor
|
|
|
|
if (magnetic_uri.length<1) {
|
|
res.json({error:true, "txnid":null, msg:'Magnetic uri is empty', data:null})
|
|
return
|
|
}
|
|
|
|
let toaddress = "oHyzdt8xW1A81qcZ5VcM25RbC6RVbynAg4";
|
|
let amount = 1;
|
|
|
|
try {
|
|
client.sendToAddress(toaddress, amount, "Webtor App", "Webtorrent", false, false, 1, 'UNSET', magnetic_uri)
|
|
.then((txnid) => {
|
|
console.log(txnid)
|
|
res.json({"error":false, "txnid":txnid, msg:"Transaction successfull."})
|
|
}).catch(e=> {
|
|
res.json({"error":true, "txnid":"NOTXIDKJKLGJLKSJLKGJSKJGK", msg:`${e.message}: Please start FLO wallet or FLOD daemon first.`, data:null})
|
|
});
|
|
} catch(err) {
|
|
console.log("Unable to send FLO." + err.message);
|
|
res.json({"error":true, "txnid":"NOTXIDKJKLGJLKSJLKGJSKJGK", msg:err.message, data:null})
|
|
}
|
|
|
|
return;
|
|
|
|
})
|
|
|
|
router.get('/fetch-from-blockchain', (req, res)=>{
|
|
res.render('from_flo', {
|
|
data: {},
|
|
errors: {},
|
|
title: 'Send the torrent to flo'
|
|
})
|
|
})
|
|
|
|
router.post('/fetch-from-blockchain', [
|
|
check('job')
|
|
.isLength({min:1})
|
|
.withMessage('Invalid job!')
|
|
.trim(),
|
|
check('floaddr')
|
|
.isLength({min:1})
|
|
.withMessage('Invalid FLO addrress!')
|
|
.trim()
|
|
], (req, res)=>{
|
|
|
|
const errors = validationResult(req)
|
|
console.log(errors.mapped());
|
|
|
|
if(!errors.isEmpty()) {
|
|
return res.render('fetch-from-blockchain', {
|
|
data: req.body,
|
|
errors: errors.mapped(),
|
|
title: 'Please correct your errors'
|
|
})
|
|
}
|
|
|
|
let params = _.pick(req.body, ['job', 'floaddr'])
|
|
|
|
if (typeof params.job == undefined || params.job!='flo-comment') {
|
|
console.log("Unknown request");
|
|
return;
|
|
}
|
|
|
|
let floaddr = params.floaddr
|
|
|
|
if (floaddr.length<1) {
|
|
res.json({error:true, "txnid":null, msg:'FLO address is empty', data:null})
|
|
return
|
|
}
|
|
|
|
try {
|
|
let tx_arr = []
|
|
client.listTransactions().then(lt=>{
|
|
|
|
for (let t = 0; t < lt.length; t++) {
|
|
const elem = lt[t];
|
|
if (elem.address==floaddr && elem.category=='receive') {
|
|
tx_arr.push(elem.txid)
|
|
}
|
|
}
|
|
return tx_arr;
|
|
|
|
}).then(tx_arr=>{
|
|
//console.log(tx_arr);
|
|
let tor_arr = []
|
|
for (const tx in tx_arr) {
|
|
let promise = funcs.getFloData(_.trim(tx_arr[tx]))
|
|
tor_arr.push(promise)
|
|
}
|
|
|
|
let msg_arr = []
|
|
Promise.all(tor_arr).then(msgr=>{
|
|
msgr.forEach(op=>{
|
|
msg_arr.push(op)
|
|
})
|
|
return msg_arr
|
|
}).then(flo_data=>{
|
|
//console.log(flo_data);
|
|
res.json({error:false, msg:'List of Torrent files:', data:flo_data})
|
|
})
|
|
}).catch(e=>{
|
|
console.error(e)
|
|
})
|
|
} catch (error) {
|
|
console.error(error)
|
|
}
|
|
|
|
})
|
|
|
|
router.get('/trackers-list', (req, res)=>{
|
|
res.render('trackers-list', {
|
|
data: {},
|
|
errors: {},
|
|
title: 'Trackers List'
|
|
})
|
|
})
|
|
|
|
router.post('/trackers-list', (req, res)=>{
|
|
|
|
require('events').EventEmitter.defaultMaxListeners = 100;
|
|
|
|
let params = _.pick(req.body, ['job', 'mag_url', 'pid'])
|
|
if (params.job!=="track list") {
|
|
return;
|
|
}
|
|
|
|
let magnetURI = params.mag_url
|
|
let peer_id = params.pid
|
|
|
|
var parsedTorrent = magnet(magnetURI)
|
|
|
|
var opts = {
|
|
infoHash: parsedTorrent.infoHash,
|
|
announce: parsedTorrent.announce,
|
|
peerId: new Buffer(peer_id), // hex string or Buffer
|
|
port: 6881 // torrent client port
|
|
}
|
|
|
|
var client = new Tracker(opts)
|
|
|
|
|
|
// start getting peers from the tracker
|
|
client.start()
|
|
|
|
client.on('update', function (data) {
|
|
console.log('got an announce response from tracker: ' + data.announce)
|
|
console.log('number of seeders in the swarm: ' + data.complete)
|
|
console.log('number of leechers in the swarm: ' + data.incomplete)
|
|
})
|
|
|
|
setInterval(function() {
|
|
console.log('Searching for peers...');
|
|
client.once('peer', function (addr) {
|
|
console.log(`******* Found a peer: ${addr} *******`) // 85.10.239.191:48623
|
|
})
|
|
}, 60000);
|
|
|
|
client.scrape()
|
|
|
|
client.on('scrape', function (data) {
|
|
res.write(JSON.stringify(data))
|
|
setInterval(function() {
|
|
res.end()
|
|
}, 60000)
|
|
})
|
|
})
|
|
|
|
module.exports = router |