cmd/btrtrc/fifos.go

   1 package main
   2
   3 import (
   4         "bufio"
   5         "bytes"
   6         "encoding/hex"
   7         "fmt"
   8         "log"
   9         "os"
  10         "path"
  11         "sort"
  12         "strconv"
  13         "strings"
  14         "sync"
  15         "syscall"
  16         "time"
  17
  18         "github.com/anacrolix/dht/v2"
  19         "github.com/anacrolix/torrent"
  20         "github.com/anacrolix/torrent/metainfo"
  21         "github.com/anacrolix/torrent/storage"
  22         "github.com/anacrolix/torrent/types/infohash"
  23         "github.com/dustin/go-humanize"
  24 )
  25
  26 const (
  27         MaxListNameWidth = 40
  28         FIFOsDir         = "fifos"
  29         PeersDir         = "peers"
  30         FilesDir         = "files"
  31 )
  32
  33 type TorrentStat struct {
  34         stats   torrent.ConnStats
  35         rxSpeed int64
  36         txSpeed int64
  37 }
  38
  39 var (
  40         TorrentStats  = map[metainfo.Hash]TorrentStat{}
  41         TorrentStatsM sync.RWMutex
  42         Torrents      []metainfo.Hash
  43         TorrentsM     sync.RWMutex
  44 )
  45
  46 func recreateFIFO(pth string) {
  47         os.Remove(pth)
  48         if err := syscall.Mkfifo(pth, 0666); err != nil {
  49                 log.Fatalln(err)
  50         }
  51 }
  52
  53 func shortenName(name string) string {
  54         s := []rune(name)
  55         if len(s) > MaxListNameWidth {
  56                 s = s[:MaxListNameWidth]
  57         }
  58         return string(s)
  59 }
  60
  61 func fifoList(c *torrent.Client) {
  62         pth := path.Join(FIFOsDir, "list")
  63         recreateFIFO(pth)
  64         for {
  65                 fd, err := os.OpenFile(pth, os.O_WRONLY|os.O_APPEND, os.FileMode(0666))
  66                 if err != nil {
  67                         log.Println("OpenFile:", pth, err)
  68                         time.Sleep(time.Second)
  69                         continue
  70                 }
  71                 ts := make([]*torrent.Torrent, 0, len(Torrents))
  72                 TorrentsM.RLock()
  73                 for _, h := range Torrents {
  74                         t, _ := c.Torrent(h)
  75                         if t == nil || t.Info() == nil {
  76                                 fmt.Fprintf(fd, "%s not ready\n", t.Name())
  77                                 continue
  78                         }
  79                         ts = append(ts, t)
  80                 }
  81                 TorrentsM.RUnlock()
  82                 for _, t := range ts {
  83                         stats := t.Stats()
  84                         done := t.BytesCompleted() * 100 / t.Length()
  85                         percColour := Red
  86                         if done == 100 {
  87                                 percColour = Green
  88                         }
  89                         tx := stats.BytesWrittenData.Int64()
  90                         tx += TxStats[t.InfoHash()]
  91                         ratio := float64(tx) / float64(t.Length())
  92                         TorrentStatsM.RLock()
  93                         prev := TorrentStats[t.InfoHash()]
  94                         TorrentStatsM.RUnlock()
  95                         var eta string
  96                         if done < 100 && prev.rxSpeed > 0 {
  97                                 etaRaw := time.Duration((t.Length() - t.BytesCompleted()) / prev.rxSpeed)
  98                                 etaRaw *= time.Second
  99                                 eta = etaRaw.String()
 100                         }
 101                         fmt.Fprintf(fd,
 102                                 "%s%s%s %s%40s%s %8s %s%3d%%%s %4.1f %s%d%s/%s%d%s %d/%d/%d/%d %s\n",
 103                                 Blue, t.InfoHash().HexString(), Reset,
 104                                 Green, shortenName(t.Name()), Reset,
 105                                 humanize.IBytes(uint64(t.Length())),
 106                                 percColour, done, Reset,
 107                                 ratio,
 108                                 Green, prev.rxSpeed/1024, Reset,
 109                                 Magenta, prev.txSpeed/1024, Reset,
 110                                 stats.TotalPeers,
 111                                 stats.PendingPeers,
 112                                 stats.ActivePeers,
 113                                 stats.ConnectedSeeders,
 114                                 eta,
 115                         )
 116                 }
 117                 fd.Close()
 118                 time.Sleep(time.Second)
 119         }
 120 }
 121
 122 func mustParseInt(s string) int {
 123         i, err := strconv.Atoi(s)
 124         if err != nil {
 125                 log.Fatalln(err)
 126         }
 127         return i
 128 }
 129
 130 func fifoPeerList(t *torrent.Torrent) {
 131         pth := path.Join(FIFOsDir, PeersDir, t.InfoHash().HexString())
 132         recreateFIFO(pth)
 133         for {
 134                 fd, err := os.OpenFile(pth, os.O_WRONLY|os.O_APPEND, os.FileMode(0666))
 135                 if err != nil {
 136                         if os.IsNotExist(err) {
 137                                 break
 138                         }
 139                         log.Println("OpenFile:", pth, err)
 140                         time.Sleep(time.Second)
 141                         continue
 142                 }
 143                 pcs := t.PeerConns()
 144                 sort.Sort(ByPeerID(pcs))
 145                 for _, pc := range pcs {
 146                         cols := strings.Split(pc.CompletedString(), "/")
 147                         done := (mustParseInt(cols[0]) * 100) / mustParseInt(cols[1])
 148                         doneColour := Red
 149                         if done == 100 {
 150                                 doneColour = Green
 151                         }
 152                         stats := pc.Peer.Stats()
 153                         fmt.Fprintf(fd,
 154                                 "%s%s%s %10s %s%3d%%%s %s%d%s/%s%d%s %s / %s | %s%s%s %q\n",
 155                                 Blue, hex.EncodeToString(pc.PeerID[:]), Reset,
 156                                 pc.StatusFlags(),
 157                                 doneColour, done, Reset,
 158                                 Green, int(pc.DownloadRate()/1024), Reset,
 159                                 Magenta, int(pc.UploadRate()/1024), Reset,
 160                                 humanize.IBytes(uint64(stats.BytesReadData.Int64())),
 161                                 humanize.IBytes(uint64(stats.BytesWrittenData.Int64())),
 162                                 Green, pc.RemoteAddr, Reset,
 163                                 pc.PeerClientName,
 164                         )
 165                 }
 166                 fd.Close()
 167                 time.Sleep(time.Second)
 168         }
 169 }
 170
 171 func fifoFileList(t *torrent.Torrent) {
 172         pth := path.Join(FIFOsDir, FilesDir, t.InfoHash().HexString())
 173         recreateFIFO(pth)
 174         for {
 175                 fd, err := os.OpenFile(pth, os.O_WRONLY|os.O_APPEND, os.FileMode(0666))
 176                 if err != nil {
 177                         if os.IsNotExist(err) {
 178                                 break
 179                         }
 180                         log.Println("OpenFile:", pth, err)
 181                         time.Sleep(time.Second)
 182                         continue
 183                 }
 184                 for n, f := range t.Files() {
 185                         var done int64
 186                         if f.Length() > 0 {
 187                                 done = (f.BytesCompleted() * 100) / f.Length()
 188                         }
 189                         percColour := Green
 190                         if done < 100 {
 191                                 percColour = Red
 192                         }
 193                         fmt.Fprintf(fd,
 194                                 "%5d %8s %3d%% | %s%s%s\n",
 195                                 n, humanize.IBytes(uint64(f.Length())), done,
 196                                 percColour, f.Path(), Reset,
 197                         )
 198                 }
 199                 fd.Close()
 200                 time.Sleep(time.Second)
 201         }
 202 }
 203
 204 func fifoDHTList(c *torrent.Client) {
 205         pth := path.Join(FIFOsDir, "dht")
 206         recreateFIFO(pth)
 207         for {
 208                 fd, err := os.OpenFile(pth, os.O_WRONLY|os.O_APPEND, os.FileMode(0666))
 209                 if err != nil {
 210                         if os.IsNotExist(err) {
 211                                 break
 212                         }
 213                         log.Println("OpenFile:", pth, err)
 214                         time.Sleep(time.Second)
 215                         continue
 216                 }
 217                 for _, s := range c.DhtServers() {
 218                         stats := s.Stats().(dht.ServerStats)
 219                         fmt.Fprintf(
 220                                 fd, "%s%s%s all:%d good:%d await:%d succ:%d bad:%d\n",
 221                                 Green, s.Addr().String(), Reset,
 222                                 stats.Nodes,
 223                                 stats.GoodNodes,
 224                                 stats.OutstandingTransactions,
 225                                 stats.SuccessfulOutboundAnnouncePeerQueries,
 226                                 stats.BadNodes,
 227                         )
 228                 }
 229                 fd.Close()
 230                 time.Sleep(time.Second)
 231         }
 232 }
 233
 234 type topTorrent struct {
 235         infoHash metainfo.Hash
 236         name     string
 237         tx       int64
 238 }
 239
 240 func fifoTopSeed(c *torrent.Client) {
 241         pth := path.Join(FIFOsDir, "top-seed")
 242         recreateFIFO(pth)
 243         for {
 244                 fd, err := os.OpenFile(pth, os.O_WRONLY|os.O_APPEND, os.FileMode(0666))
 245                 if err != nil {
 246                         log.Println("OpenFile:", pth, err)
 247                         time.Sleep(time.Second)
 248                         continue
 249                 }
 250                 var ts []*topTorrent
 251                 for _, t := range c.Torrents() {
 252                         if t.Info() == nil {
 253                                 continue
 254                         }
 255                         stats := t.Stats()
 256                         ts = append(ts, &topTorrent{
 257                                 infoHash: t.InfoHash(),
 258                                 name:     t.Name(),
 259                                 tx:       stats.BytesWrittenData.Int64() + TxStats[t.InfoHash()],
 260                         })
 261                 }
 262                 sort.Sort(ByTxTraffic(ts))
 263                 for _, t := range ts {
 264                         fmt.Fprintf(fd,
 265                                 "%s%s%s %s%40s%s %s\n",
 266                                 Blue, t.infoHash.HexString(), Reset,
 267                                 Green, shortenName(t.name), Reset,
 268                                 humanize.IBytes(uint64(t.tx)),
 269                         )
 270                 }
 271                 fd.Close()
 272                 time.Sleep(time.Second)
 273         }
 274 }
 275
 276 type stringAddr string
 277
 278 func (stringAddr) Network() string   { return "" }
 279 func (me stringAddr) String() string { return string(me) }
 280
 281 func resolveTestPeers(addrs []string) (ret []torrent.PeerInfo) {
 282         for _, ta := range addrs {
 283                 ret = append(ret, torrent.PeerInfo{Addr: stringAddr(ta)})
 284         }
 285         return
 286 }
 287
 288 func readLinesFromFIFO(pth string) []string {
 289         fd, err := os.OpenFile(pth, os.O_RDONLY, os.FileMode(0666))
 290         if err != nil {
 291                 log.Println("OpenFile:", pth, err)
 292                 time.Sleep(time.Second)
 293                 return nil
 294         }
 295         var lines []string
 296         scanner := bufio.NewScanner(fd)
 297         for scanner.Scan() {
 298                 t := scanner.Text()
 299                 if len(t) > 0 {
 300                         lines = append(lines, t)
 301                 }
 302         }
 303         fd.Close()
 304         return lines
 305 }
 306
 307 func saveTorrent(t *torrent.Torrent) error {
 308         pth := storage.PathShortener(t.Name()) + TorrentExt
 309         if _, err := os.Stat(pth); err == nil {
 310                 return nil
 311         }
 312         var b bytes.Buffer
 313         t.Metainfo().Write(&b)
 314         return os.WriteFile(pth, b.Bytes(), 0666)
 315 }
 316
 317 func fifoAdd(c *torrent.Client) {
 318         pth := path.Join(FIFOsDir, "add")
 319         recreateFIFO(pth)
 320         for {
 321                 for _, what := range readLinesFromFIFO(pth) {
 322                         cols := strings.Fields(what)
 323                         what = cols[0]
 324                         var t *torrent.Torrent
 325                         var err error
 326                         if strings.HasPrefix(what, "magnet:") {
 327                                 t, err = c.AddMagnet(what)
 328                                 if err != nil {
 329                                         log.Println("AddMagnet:", what, err)
 330                                         continue
 331                                 }
 332                         } else {
 333                                 metaInfo, err := metainfo.LoadFromFile(what)
 334                                 if err != nil {
 335                                         log.Println("LoadFromFile:", what, err)
 336                                         continue
 337                                 }
 338                                 t, err = c.AddTorrent(metaInfo)
 339                                 if err != nil {
 340                                         log.Println("AddTorrent:", what, err)
 341                                         continue
 342                                 }
 343                         }
 344                         if len(cols) > 1 {
 345                                 t.AddPeers(resolveTestPeers(cols[1:]))
 346                         }
 347                         TorrentsM.Lock()
 348                         for _, h := range Torrents {
 349                                 if h.HexString() == t.InfoHash().HexString() {
 350                                         goto OldOne
 351                                 }
 352                         }
 353                         Torrents = append(Torrents, t.InfoHash())
 354                 OldOne:
 355                         TorrentsM.Unlock()
 356                         go fifoPeerList(t)
 357                         go fifoFileList(t)
 358                         log.Println("added:", t.InfoHash().HexString(), t.Name())
 359                         go func() {
 360                                 <-t.GotInfo()
 361                                 if err = saveTorrent(t); err != nil {
 362                                         log.Println("saveTorrent:", err)
 363                                 }
 364                                 txStatsLoad(t.InfoHash())
 365                                 t.DownloadAll()
 366                         }()
 367                 }
 368                 time.Sleep(time.Second)
 369         }
 370 }
 371
 372 func fifoDel(c *torrent.Client) {
 373         pth := path.Join(FIFOsDir, "del")
 374         recreateFIFO(pth)
 375         for {
 376                 for _, what := range readLinesFromFIFO(pth) {
 377                         raw, err := hex.DecodeString(what)
 378                         if err != nil {
 379                                 log.Println(err)
 380                                 continue
 381                         }
 382                         if len(raw) != infohash.Size {
 383                                 log.Println("bad length")
 384                                 continue
 385                         }
 386                         var i infohash.T
 387                         copy(i[:], raw)
 388                         TorrentsM.Lock()
 389                         for n, h := range Torrents {
 390                                 if h.HexString() == i.HexString() {
 391                                         Torrents = append(Torrents[:n], Torrents[n+1:]...)
 392                                         break
 393                                 }
 394                         }
 395                         TorrentsM.Unlock()
 396                         t, ok := c.Torrent(i)
 397                         if !ok {
 398                                 log.Println("no such torrent", what)
 399                                 continue
 400                         }
 401                         txStatsDump(t)
 402                         txStatsDel(t.InfoHash())
 403                         t.Drop()
 404                         for _, where := range []string{"files", "peers"} {
 405                                 pth := path.Join(where, t.InfoHash().HexString())
 406                                 os.Remove(pth)
 407                                 fd, err := os.Open(pth)
 408                                 if err == nil {
 409                                         fd.Close()
 410                                 }
 411                         }
 412                         log.Println("deleted:", what, t.Name())
 413                 }
 414                 time.Sleep(time.Second)
 415         }
 416 }
 417
 418 func fifosPrepare() {
 419         os.MkdirAll(path.Join(FIFOsDir, PeersDir), 0777)
 420         os.MkdirAll(path.Join(FIFOsDir, FilesDir), 0777)
 421 }
 422
 423 func fifosCleanup() {
 424         os.Remove(path.Join(FIFOsDir, "list"))
 425         os.Remove(path.Join(FIFOsDir, "dht"))
 426         os.Remove(path.Join(FIFOsDir, "add"))
 427         os.Remove(path.Join(FIFOsDir, "del"))
 428         os.Remove(path.Join(FIFOsDir, "top-seed"))
 429         os.RemoveAll(path.Join(FIFOsDir, PeersDir))
 430         os.RemoveAll(path.Join(FIFOsDir, FilesDir))
 431 }