go-transmission-stats/cgi-bin/main.go

package main

import (
	"fmt"
	"log"
	"os"
	"sort"
	"time"

	"github.com/hekmon/cunits/v2"
	"github.com/hekmon/transmissionrpc"
	"github.com/olekukonko/tablewriter"
)

func byteCountIEC(b int64) string {
	const unit = 1024
	if b < unit {
		return fmt.Sprintf("%d B", b)
	}

	div, exp := int64(unit), 0
	for n := b / unit; n >= unit; n /= unit {
		div *= unit
		exp++
	}

	return fmt.Sprintf("%.1f %ciB", float64(b)/float64(div), "KMGTPE"[exp])
}

func convertTime(seconds int64) string {
	switch {
	case seconds > 86400:
		day := seconds / 86400
		remainder := seconds % 86400
		hour := remainder / 3600
		remainder = remainder % 3600
		minutes := remainder / 60
		remainder = remainder % 60

		return fmt.Sprintf("%d days, %d hours, %d minutes, %d seconds", day, hour, minutes, remainder)

	case seconds < 86400 && seconds > 3600:
		hour := seconds / 3600
		remainder := seconds % 3600
		minutes := remainder / 60
		remainder = remainder % 60

		return fmt.Sprintf("%d hours, %d minutes, %d seconds", hour, minutes, remainder)

	case seconds < 3600 && seconds > 60:
		minutes := seconds / 60
		remainder := seconds % 60

		return fmt.Sprintf("%d minutes, %d seconds", minutes, remainder)

	default:
		return fmt.Sprintf("%d seconds", seconds)
	}

}

type TorrentInfo struct {
	Name               string
	DateAdded          time.Time
	TotalSize          cunits.Bits
	PeersConnected     int64
	PeersGettingFromUs int64
}

func main() {
	fmt.Println("20 text/gemini\r")
	fmt.Println("```")

	transmissionbt, err := transmissionrpc.New(os.Getenv("RPC_HOST"), os.Getenv("RPC_USER"), os.Getenv("RPC_PASSWD"), nil)
	if err != nil {
		log.Fatalln(err)
	}

	stats, err := transmissionbt.SessionStats()
	if err != nil {
		log.Fatalln(err)
	}

	sessionStats := [][]string{
		{"Active torrent count", fmt.Sprintf("%d", stats.ActiveTorrentCount)},
		{"Download speed", fmt.Sprintf("%s/sec", byteCountIEC(stats.DownloadSpeed))},
		{"Upload speed", fmt.Sprintf("%s/sec", byteCountIEC(stats.UploadSpeed))},
		{"Paused torrent count", fmt.Sprintf("%d", stats.PausedTorrentCount)},
		{"Torrent count", fmt.Sprintf("%d", stats.TorrentCount)},
	}

	fmt.Println("SESSION STATS")
	fmt.Println()
	sessionStatsTable := tablewriter.NewWriter(os.Stdout)
	sessionStatsTable.SetAlignment(tablewriter.ALIGN_LEFT)
	sessionStatsTable.SetBorder(false)
	sessionStatsTable.SetCenterSeparator("│")
	sessionStatsTable.SetColumnSeparator("│")
	sessionStatsTable.SetRowLine(true)
	sessionStatsTable.SetRowSeparator("─")
	sessionStatsTable.AppendBulk(sessionStats)
	sessionStatsTable.Render()
	fmt.Println()

	currentStats := [][]string{
		{"Uploaded bytes", fmt.Sprintf("%s", byteCountIEC(stats.CurrentStats.UploadedBytes))},
		{"Downloaded bytes", fmt.Sprintf("%s", byteCountIEC(stats.CurrentStats.DownloadedBytes))},
		{"Files added", fmt.Sprintf("%d", stats.CurrentStats.FilesAdded)},
		{"Session count", fmt.Sprintf("%d", stats.CurrentStats.SessionCount)},
		{"Time active", convertTime(stats.CurrentStats.SecondsActive)},
	}

	fmt.Println("CURRENT STATS")
	fmt.Println()
	currentStatsTable := tablewriter.NewWriter(os.Stdout)
	currentStatsTable.SetAlignment(tablewriter.ALIGN_LEFT)
	currentStatsTable.SetBorder(false)
	currentStatsTable.SetCenterSeparator("│")
	currentStatsTable.SetColumnSeparator("│")
	currentStatsTable.SetRowLine(true)
	currentStatsTable.SetRowSeparator("─")
	currentStatsTable.AppendBulk(currentStats)
	currentStatsTable.Render()
	fmt.Println()

	cumulativeStats := [][]string{
		{"Uploaded bytes", fmt.Sprintf("%s", byteCountIEC(stats.CumulativeStats.UploadedBytes))},
		{"Downloaded bytes", fmt.Sprintf("%s", byteCountIEC(stats.CumulativeStats.DownloadedBytes))},
		{"Files added", fmt.Sprintf("%d", stats.CumulativeStats.FilesAdded)},
		{"Session count", fmt.Sprintf("%d", stats.CumulativeStats.SessionCount)},
		{"Time active", convertTime(stats.CumulativeStats.SecondsActive)},
	}

	fmt.Println("CUMULATIVE STATS")
	fmt.Println()
	cumulativeStatsTable := tablewriter.NewWriter(os.Stdout)
	cumulativeStatsTable.SetAlignment(tablewriter.ALIGN_LEFT)
	cumulativeStatsTable.SetBorder(false)
	cumulativeStatsTable.SetCenterSeparator("│")
	cumulativeStatsTable.SetColumnSeparator("│")
	cumulativeStatsTable.SetRowLine(true)
	cumulativeStatsTable.SetRowSeparator("─")
	cumulativeStatsTable.AppendBulk(cumulativeStats)
	cumulativeStatsTable.Render()
	fmt.Println()

	var torrentInfo = []TorrentInfo{}
	torrents, err := transmissionbt.TorrentGet([]string{"name", "addedDate", "totalSize", "peersConnected", "peersGettingFromUs"}, nil)
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
	} else {
		for _, torrent := range torrents {
			torrentInfo = append(torrentInfo, TorrentInfo{Name: *torrent.Name, DateAdded: *torrent.AddedDate, TotalSize: *torrent.TotalSize, PeersConnected: *torrent.PeersConnected, PeersGettingFromUs: *torrent.PeersGettingFromUs})
		}
	}

	sort.Slice(torrentInfo, func(i, j int) bool {
		return torrentInfo[i].Name < torrentInfo[j].Name
	})

	fmt.Println("TORRENT INFO")
	fmt.Println()
	torrentStatsTable := tablewriter.NewWriter(os.Stdout)
	torrentStatsTable.SetHeader([]string{"Name", "Date Added", "Total Size", "Peers Connected", "Peers Getting From Us"})
	torrentStatsTable.SetAlignment(tablewriter.ALIGN_LEFT)
	torrentStatsTable.SetBorder(false)
	torrentStatsTable.SetCenterSeparator("│")
	torrentStatsTable.SetColumnSeparator("│")
	torrentStatsTable.SetRowLine(true)
	torrentStatsTable.SetRowSeparator("─")

	for _, v := range torrentInfo {
		torrentStatsTable.Append([]string{v.Name, fmt.Sprintf("%s", v.DateAdded), byteCountIEC(int64(v.TotalSize)), fmt.Sprintf("%d", v.PeersConnected), fmt.Sprintf("%d", v.PeersGettingFromUs)})
	}

	torrentStatsTable.Render()
}