cmd/torrent/main.go

   1 // Downloads torrents from the command-line.
   2 package main
   3
   4 import (
   5         "fmt"
   6         stdLog "log"
   7         "net/http"
   8
   9         "github.com/anacrolix/bargle"
  10         "github.com/anacrolix/envpprof"
  11         xprometheus "github.com/anacrolix/missinggo/v2/prometheus"
  12         "github.com/anacrolix/torrent/version"
  13         "github.com/prometheus/client_golang/prometheus"
  14         "github.com/prometheus/client_golang/prometheus/promhttp"
  15 )
  16
  17 func init() {
  18         prometheus.MustRegister(xprometheus.NewExpvarCollector())
  19         http.Handle("/metrics", promhttp.Handler())
  20 }
  21
  22 func main() {
  23         defer stdLog.SetFlags(stdLog.Flags() | stdLog.Lshortfile)
  24         main := bargle.Main{}
  25         main.Defer(envpprof.Stop)
  26         debug := false
  27         debugFlag := bargle.NewFlag(&debug)
  28         debugFlag.AddLong("debug")
  29         main.Options = append(main.Options, debugFlag.Make())
  30         main.Positionals = append(main.Positionals,
  31                 bargle.Subcommand{Name: "metainfo", Command: metainfoCmd()},
  32                 //bargle.Subcommand{Name: "announce", Command: func() bargle.Command {
  33                 //      var cmd AnnounceCmd
  34                 //      err := p.NewParser().AddParams(
  35                 //              args.Pos("tracker", &cmd.Tracker),
  36                 //              args.Pos("infohash", &cmd.InfoHash)).Parse()
  37                 //      if err != nil {
  38                 //              return err
  39                 //      }
  40                 //      return announceErr(cmd)
  41                 //}()},
  42                 bargle.Subcommand{Name: "scrape", Command: func() bargle.Command {
  43                         var scrapeCfg scrapeCfg
  44                         cmd := bargle.FromStruct(&scrapeCfg)
  45                         cmd.Desc = "fetch swarm metrics for info-hashes from tracker"
  46                         cmd.DefaultAction = func() error {
  47                                 return scrape(scrapeCfg)
  48                         }
  49                         return cmd
  50                 }()},
  51                 bargle.Subcommand{Name: "download", Command: func() bargle.Command {
  52                         var dlc DownloadCmd
  53                         cmd := bargle.FromStruct(&dlc)
  54                         cmd.DefaultAction = func() error {
  55                                 return downloadErr(downloadFlags{
  56                                         Debug:       debug,
  57                                         DownloadCmd: dlc,
  58                                 })
  59                         }
  60                         return cmd
  61                 }()},
  62                 //bargle.Subcommand{Name:
  63                 //      "bencode", Command: func() bargle.Command {
  64                 //              var print func(interface{}) error
  65                 //              if !p.Parse(
  66                 //                      args.Subcommand("json", func(ctx args.SubCmdCtx) (err error) {
  67                 //                              ctx.Parse()
  68                 //                              je := json.NewEncoder(os.Stdout)
  69                 //                              je.SetIndent("", "  ")
  70                 //                              print = je.Encode
  71                 //                              return nil
  72                 //                      }),
  73                 //                      args.Subcommand("spew", func(ctx args.SubCmdCtx) (err error) {
  74                 //                              ctx.Parse()
  75                 //                              config := spew.NewDefaultConfig()
  76                 //                              config.DisableCapacities = true
  77                 //                              config.Indent = "  "
  78                 //                              print = func(v interface{}) error {
  79                 //                                      config.Dump(v)
  80                 //                                      return nil
  81                 //                              }
  82                 //                              return nil
  83                 //                      }),
  84                 //              ).RanSubCmd {
  85                 //                      return errors.New("an output type is required")
  86                 //              }
  87                 //              d := bencode.NewDecoder(os.Stdin)
  88                 //              p.Defer(func() error {
  89                 //                      for i := 0; ; i++ {
  90                 //                              var v interface{}
  91                 //                              err := d.Decode(&v)
  92                 //                              if err == io.EOF {
  93                 //                                      break
  94                 //                              }
  95                 //                              if err != nil {
  96                 //                                      return fmt.Errorf("decoding message index %d: %w", i, err)
  97                 //                              }
  98                 //                              print(v)
  99                 //                      }
 100                 //                      return nil
 101                 //              })
 102                 //              return nil
 103                 //      }(),
 104                 //      Desc: "reads bencoding from stdin into Go native types and spews the result",
 105                 //},
 106                 bargle.Subcommand{Name: "version", Command: bargle.Command{
 107                         DefaultAction: func() error {
 108                                 fmt.Printf("HTTP User-Agent: %q\n", version.DefaultHttpUserAgent)
 109                                 fmt.Printf("Torrent client version: %q\n", version.DefaultExtendedHandshakeClientVersion)
 110                                 fmt.Printf("Torrent version prefix: %q\n", version.DefaultBep20Prefix)
 111                                 return nil
 112                         },
 113                         Desc: "prints various protocol default version strings",
 114                 }},
 115                 bargle.Subcommand{Name: "serve", Command: serve()},
 116                 bargle.Subcommand{Name: "create", Command: create()},
 117         )
 118         main.Run()
 119 }