How to use parse-torrent - 10 common examples

//      'c9dd51027467519d5eb2561ae2cc01467de5f643',
//      '0a60bcba24797692efa8770d23df0a830d91cb35',
//      'b3407a88baa0590dc8c9aa6a120f274367dcd867',
//      'e88e8338c572a06e3c801b29f519df532b3e76f6',
//      '70cf6aee53107f3d39378483f69cf80fa568b1ea',
//      'c53b506159e988d8bc16922d125d77d803d652c3',
//      'ca3070c16eed9172ab506d20e522ea3f1ab674b3',
//      'f923d76fe8f44ff32e372c3b376564c6fb5f0dbe',
//      '52164f03629fd1322636babb2c014b7dae582da4',
//      '1363965261e6ce12b43701f0a8c9ed1520a70eba',
//      '004400a267765f6d3dd5c7beb5bd3c75f3df2a54',
//      '560a61801147fa4ec7cf568e703acb04e5610a4d',
//      '56dcc242d03293e9446cf5e457d8eb3d9588fd90',
//      'c698de9b0dad92980906c026d8c1408fa08fe4ec' ] }

const uri = parseTorrent.toMagnetURI({
    infoHash: 'd2474e86c95b19b8bcfdb92bc12c9d44667cfa36',
});

const buf = parseTorrent.toTorrentFile({
    infoHash: 'd2474e86c95b19b8bcfdb92bc12c9d44667cfa36',
});

parseTorrent.remote('d2474e86c95b19b8bcfdb92bc12c9d44667cfa36', (err, parsedTorrent) => {
    // if (err) throw err
    // console.log(parsedTorrent)
});

//      '70cf6aee53107f3d39378483f69cf80fa568b1ea',
//      'c53b506159e988d8bc16922d125d77d803d652c3',
//      'ca3070c16eed9172ab506d20e522ea3f1ab674b3',
//      'f923d76fe8f44ff32e372c3b376564c6fb5f0dbe',
//      '52164f03629fd1322636babb2c014b7dae582da4',
//      '1363965261e6ce12b43701f0a8c9ed1520a70eba',
//      '004400a267765f6d3dd5c7beb5bd3c75f3df2a54',
//      '560a61801147fa4ec7cf568e703acb04e5610a4d',
//      '56dcc242d03293e9446cf5e457d8eb3d9588fd90',
//      'c698de9b0dad92980906c026d8c1408fa08fe4ec' ] }

const uri = parseTorrent.toMagnetURI({
    infoHash: 'd2474e86c95b19b8bcfdb92bc12c9d44667cfa36',
});

const buf = parseTorrent.toTorrentFile({
    infoHash: 'd2474e86c95b19b8bcfdb92bc12c9d44667cfa36',
});

parseTorrent.remote('d2474e86c95b19b8bcfdb92bc12c9d44667cfa36', (err, parsedTorrent) => {
    // if (err) throw err
    // console.log(parsedTorrent)
});

if (that.type === 'torrent' || that.type === 'metalink') {
          let reader = new FileReader()
          reader.onload = (e) => {
            that.file = e.target.result.replace(/^.*base64,/, '')
            that.filename = file.name
          }
          reader.onerror = (error) => {
            console.error(error.message)
            that.file = undefined
            that.filename = ''
            that.type = 'http'
          }
          reader.readAsDataURL(file)

          if (that.type === 'torrent') {
            parseTorrent.remote(file, (err, parsedTorrent) => {
              if (err) {
                that.filesInTorrent = []
                console.error(err)
              } else {
                that.filesInTorrent = parsedTorrent.files.map((file, index) => {
                  return {
                    // aria2's select-file uses starting index 1
                    index: index + 1,
                    name: file.name,
                    extension: file.name.includes('.') ? file.name.split('.').pop() : '',
                    size: file.length,
                    selected: true
                  }
                })
              }
            })

return new Promise((resolve, reject) => {
			if(!this._hash){
				this._state = State.INVALID;
				return reject(INVALID_ERROR());
			}

			// Do not init() twice
			if(this.isInitialized())
				return reject(new TypeError('Torrent '+self._hash+' is already initialized'));

			var parsed;
			try {
				parsed = parseTorrent(this._source);

			} catch(err) {
				return reject(err);
			}
			self._init = true;
			self._title = parsed.name || 'loading title...';
			self._state = State.LOADING;
			
			this.emit('change');
			this.emit('change:state');
			this.emit('initializing');

			this._torrent = this._config.client.add(this._source, (torr) => {
				console.log('TORRENT ADDED');
				this._state = State.CONNECTING;
				this.emit('change');

self.createdBy = torrentMeta.createdBy
  self.announce = torrentMeta.announce
  self.urlList = self._customWebSeeds.concat(torrentMeta.urlList)
  self.length = torrentMeta.length
  self.pieceLength = torrentMeta.pieceLength
  self.lastPieceLength = torrentMeta.lastPieceLength
  self.pieces = torrentMeta.pieces
  self.info = torrentMeta.info
  self.magnetURI = parseTorrent.toMagnetURI(torrentMeta)

  // TODO is it better to check 'info' instead?
  if (torrentMeta.files && torrentMeta.pieceLength) {
    self.files = torrentMeta.files.map(function (f) { return new File(self, f) })
    self._chunkStore = self._torrentDB.createChunkStore(self.pieceLength)
    self._chunkStore._store.on('set', self._onChunkPut.bind(self))
    self.torrentMetaBuffer = parseTorrent.toTorrentFile(torrentMeta)
    self.ready = true
    self.emit('ready')
  }
}

r.table('videos').insert({infoHash: parsedTorrent.infoHash, name: req.body.name, torrent: parsedTorrent, peers: 0, createdAt: r.now()}).run().then((result) => {
      // lg(result)
      res.redirect('/')
    })

    try {
      fs.accessSync('public/videos/' + parsedTorrent.infoHash, fs.F_OK)
      // Do something
      return
    } catch (e) {
      console.error(e)
      // It isn't accessible
      lg("doesn't exist")
    }

    torrent = parseTorrent.toTorrentFile(parsedTorrent)

    fs.mkdir('public/videos/' + parsedTorrent.infoHash, (err) => {
      if (err) console.error(err)
      fs.writeFile('public/videos/' + parsedTorrent.infoHash + '/' + parsedTorrent.infoHash + '.torrent', torrent)
      fs.rename('tmp/' + req.file.filename, 'public/videos/' + parsedTorrent.infoHash + '/' + parsedTorrent.infoHash + '.mp4', (err) => {
        if (err) console.error(err)
      })
    })
  })
})

function handleAddTorrent (server, message) {
  var clientKey = message.clientKey
  var torrentKey = message.torrentKey

  // First, see if we've already joined this swarm
  parseTorrent.remote(message.torrentId, function (err, parsedTorrent) {
    if (err) {
      sendSubscribed(server, null, clientKey, torrentKey)
    } else {
      var infoHash = parsedTorrent.infoHash
      var torrent = server._torrents.find(function (t) {
        return t.infoHash === infoHash
      })

      // If not, add the torrent to the client
      if (!torrent) {
        debug('add torrent: ' + infoHash + ' ' + (parsedTorrent.name || ''))
        torrent = server.webtorrent().add(message.torrentId, message.opts)
        torrent.clients = []
        server._torrents.push(torrent)
        addTorrentEvents(server, torrent)
      }

if (this.destroyed) return

    let parsedTorrent
    try { parsedTorrent = parseTorrent(torrentId) } catch (err) {}
    if (parsedTorrent) {
      // Attempt to set infoHash property synchronously
      this.infoHash = parsedTorrent.infoHash
      this._debugId = parsedTorrent.infoHash.toString('hex').substring(0, 7)
      process.nextTick(() => {
        if (this.destroyed) return
        this._onParsedTorrent(parsedTorrent)
      })
    } else {
      // If torrentId failed to parse, it could be in a form that requires an async
      // operation, i.e. http/https link, filesystem path, or Blob.
      parseTorrent.remote(torrentId, (err, parsedTorrent) => {
        if (this.destroyed) return
        if (err) return this._destroy(err)
        this._onParsedTorrent(parsedTorrent)
      })
    }
  }

if (this.client.tracker && global.WEBTORRENT_ANNOUNCE && !this.private) {
      // So `webtorrent-hybrid` can force specific trackers to be used
      parsedTorrent.announce = parsedTorrent.announce.concat(global.WEBTORRENT_ANNOUNCE)
    }

    if (this.urlList) {
      // Allow specifying web seeds via `opts` parameter
      parsedTorrent.urlList = parsedTorrent.urlList.concat(this.urlList)
    }

    uniq(parsedTorrent.announce)
    uniq(parsedTorrent.urlList)

    Object.assign(this, parsedTorrent)

    this.magnetURI = parseTorrent.toMagnetURI(parsedTorrent)
    this.torrentFile = parseTorrent.toTorrentFile(parsedTorrent)
  }

basicTorrentData(torrentUrl, cb)
            }
        })
    } else if (isTorrentString.isTorrentPath(torrent)) {
        // local .torrent
        let parsed

        try {
            parsed = parseTorrent(fs.readFileSync(torrent))
        } catch (e) { }

        if (parsed) {
            if (parsed.info && parsed.info.private) {
                cb(null, torrent, parsed)
            } else {
                cb(null, parseTorrent.toMagnetURI(parsed), parsed)
            }
        } else {
            cb(new Error('Could not read torrent file'))
        }
    } else {
        cb(new Error('Unsupported source'))
    }
}