cmd/torrent/main.go

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