cmd/torrent/main.go

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