Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
err.message);
}
broadcast.isLoading = false;
skipSong(broadcast);
});
// Spawn thread for starting audio stream.
const input = {
song: broadcast.current.song,
special: special,
ytdlOpts: ytdlOpts,
};
if (broadcast.current.info) {
input.song = broadcast.current.info.url;
}
broadcast.current.thread = spawn(startStream);
broadcast.current.thread.send(input);
broadcast.current.thread.on('progress', function(data) {
if (data.ytdlinfo) {
broadcast.current.oninfo(data.ytdlinfo);
return;
}
if (data.data) data.data = Buffer.from(data.data);
broadcast.current.readable.push(data.data);
});
broadcast.current.thread.on('done', function() {
broadcast.current.thread.kill();
});
broadcast.current.thread.on('error', function(err) {
self.error('Error in thread: ' + broadcast.current.song);
console.log(err);
if (broadcast.current.request) {
export async function fetchAllAssets(testnet: boolean): Promise {
const storageKey = testnet ? "known-assets:testnet" : "known-assets:mainnet"
const cachedAssetsString = localStorage.getItem(storageKey)
const timestamp = localStorage.getItem("known-assets:timestamp")
if (cachedAssetsString && timestamp && +timestamp > Date.now() - 24 * 60 * 60 * 1000) {
// use cached assets if they are not older than 24h
return JSON.parse(cachedAssetsString)
} else {
const fetcher = await spawn(new Worker("../workers/fetch-worker.ts"))
const allAssets = await fetcher.fetchAllAssets(testnet)
await Thread.terminate(fetcher)
localStorage.setItem(storageKey, JSON.stringify(allAssets))
localStorage.setItem("known-assets:timestamp", Date.now().toString())
return allAssets
}
}
'use strict';
const fs = require('fs');
const Log = require('log');
const settings = require('config');
const spawn = require('threads').spawn;
const stats = require('stats-lite');
const sprintf = require('sprintf-js').sprintf;
const terminal = spawn('./lib/terminal.js');
const threads = require('threads');
if (settings.get('general.log')) {
var log = new Log(settings.get('general.log_level'), fs.createWriteStream('GDAX.log'));
} else {
let dev_null = (process.platform === 'win32') ? 'nul' : '/dev/null'
var log = new Log(settings.get('general.log_level'), fs.createWriteStream(dev_null));
}
var terminal_data = {
account: {
// timestamp: new Date,
// profile_id: 'e316cb9a-TEMP-FAKE-DATA-97829c1925de',
// id: '343bb963-TEMP-FAKE-DATA-8b562d2f7a4e',
// account: {
// id: "a1b2c3d4",
function spawnThread(inputCallback: Function, threadCallback: Function, timeoutCallback: Function): void {
const thread = spawn((input: string, postMessage: Function) => {
postMessage(eval(input));
});
const timeout = setTimeout(() => {
thread.kill();
timeoutCallback();
}, 1500);
thread
.send(inputCallback())
.on('message', (response: number) => {
clearTimeout(timeout);
thread.kill();
threadCallback(response);
});
}
constructor(dataConfig) {
this.dataConfig = dataConfig;
this.uid = slugid.nice();
this.worker = spawn(
new Worker('./bam-fetcher-worker.js')
);
this.initPromise = this.worker.then((tileFunctions) => {
console.log('tileFunctions:', tileFunctions);
return tileFunctions.init(
this.uid, dataConfig.url, dataConfig.chromSizesUrl
).then(() => this.worker);
});
console.log('constructor');
}
'use strict'
const axios = require('axios')
const container = require('@arkecosystem/core-container')
const logger = container.resolvePlugin('logger')
const config = container.resolvePlugin('config')
const threads = require('threads')
const thread = threads.spawn(`${__dirname}/workers/download.js`)
module.exports = class Peer {
/**
* @constructor
* @param {String} ip
* @param {Number} port
* @param {Object} config
*/
constructor (ip, port, config) {
this.ip = ip
this.port = port
this.ban = new Date().getTime()
this.url = (port % 443 === 0 ? 'https://' : 'http://') + `${ip}:${port}`
this.state = {}
this.headers = {
version: config.server.version,
function spawnNetWorker() {
window.addEventListener("message", event => {
if (event.data && ["app:pause", "app:resume"].indexOf(event.data) > -1) {
netWorker.postMessage(event.data)
}
})
return spawn(netWorker)
}
function open_websocket() {
websocket = spawn('./lib/websocket.js');
websocket
.on('message', function (message) {
log.info(process.pid, 'websocket message', message.action, message);
switch (message.action) {
case 'getAccounts':
if (message.data && message.data.message) {
log.error(process.pid, message.action, message.data.message);
} else if (message.data)
{
if (terminal_data.account === undefined)
{
terminal_data.account = {};
}
terminal_data.account.timestamp = message.timestamp;
return new Promise(resolve => {
var thread = spawn('./server/workers/graphLayoutWorker.js')
.send(data)
.on('message', (res) => resolve(res))
.on('done', () => thread.kill());
});
}