]> Cypherpunks.ru repositories - nncp.git/blob - src/cmd/nncp-stat/main.go
Merge branch 'develop'
[nncp.git] / src / cmd / nncp-stat / main.go
1 /*
2 NNCP -- Node to Node copy, utilities for store-and-forward data exchange
3 Copyright (C) 2016-2021 Sergey Matveev <stargrave@stargrave.org>
4
5 This program is free software: you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation, version 3 of the License.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 GNU General Public License for more details.
13
14 You should have received a copy of the GNU General Public License
15 along with this program.  If not, see <http://www.gnu.org/licenses/>.
16 */
17
18 // Show queued NNCP Rx/Tx stats.
19 package main
20
21 import (
22         "flag"
23         "fmt"
24         "log"
25         "os"
26         "sort"
27
28         "github.com/dustin/go-humanize"
29         "go.cypherpunks.ru/nncp/v5"
30 )
31
32 func usage() {
33         fmt.Fprintf(os.Stderr, nncp.UsageHeader())
34         fmt.Fprintf(os.Stderr, "nncp-stat -- show queued Rx/Tx stats\n\n")
35         fmt.Fprintf(os.Stderr, "Usage: %s [options] [-pkt] [-node NODE]\nOptions:\n", os.Args[0])
36         flag.PrintDefaults()
37 }
38
39 func jobPrint(xx nncp.TRxTx, job nncp.Job) {
40         fmt.Printf(
41                 "\t%s %s %s (nice: %s)\n",
42                 string(xx),
43                 nncp.Base32Codec.EncodeToString(job.HshValue[:]),
44                 humanize.IBytes(uint64(job.Size)),
45                 nncp.NicenessFmt(job.PktEnc.Nice),
46         )
47 }
48
49 func main() {
50         var (
51                 showPkt   = flag.Bool("pkt", false, "Show packets listing")
52                 cfgPath   = flag.String("cfg", nncp.DefaultCfgPath, "Path to configuration file")
53                 nodeRaw   = flag.String("node", "", "Process only that node")
54                 spoolPath = flag.String("spool", "", "Override path to spool")
55                 debug     = flag.Bool("debug", false, "Print debug messages")
56                 version   = flag.Bool("version", false, "Print version information")
57                 warranty  = flag.Bool("warranty", false, "Print warranty information")
58         )
59         flag.Usage = usage
60         flag.Parse()
61         if *warranty {
62                 fmt.Println(nncp.Warranty)
63                 return
64         }
65         if *version {
66                 fmt.Println(nncp.VersionGet())
67                 return
68         }
69
70         ctx, err := nncp.CtxFromCmdline(*cfgPath, *spoolPath, "", false, false, false, *debug)
71         if err != nil {
72                 log.Fatalln("Error during initialization:", err)
73         }
74
75         var nodeOnly *nncp.Node
76         if *nodeRaw != "" {
77                 nodeOnly, err = ctx.FindNode(*nodeRaw)
78                 if err != nil {
79                         log.Fatalln("Invalid -node specified:", err)
80                 }
81         }
82
83         nodeNames := make([]string, 0, len(ctx.Neigh))
84         nodeNameToNode := make(map[string]*nncp.Node, len(ctx.Neigh))
85         for _, node := range ctx.Neigh {
86                 nodeNames = append(nodeNames, node.Name)
87                 nodeNameToNode[node.Name] = node
88         }
89         sort.Strings(nodeNames)
90
91         ctx.Umask()
92         var node *nncp.Node
93         for _, nodeName := range nodeNames {
94                 node = nodeNameToNode[nodeName]
95                 if nodeOnly != nil && *node.Id != *nodeOnly.Id {
96                         continue
97                 }
98                 fmt.Println(node.Name)
99                 rxNums := make(map[uint8]int)
100                 rxBytes := make(map[uint8]int64)
101                 noCKNums := make(map[uint8]int)
102                 noCKBytes := make(map[uint8]int64)
103                 for job := range ctx.Jobs(node.Id, nncp.TRx) {
104                         if *showPkt {
105                                 jobPrint(nncp.TRx, job)
106                         }
107                         rxNums[job.PktEnc.Nice] = rxNums[job.PktEnc.Nice] + 1
108                         rxBytes[job.PktEnc.Nice] = rxBytes[job.PktEnc.Nice] + job.Size
109                 }
110                 for job := range ctx.JobsNoCK(node.Id) {
111                         if *showPkt {
112                                 jobPrint(nncp.TRx, job)
113                         }
114                         noCKNums[job.PktEnc.Nice] = noCKNums[job.PktEnc.Nice] + 1
115                         noCKBytes[job.PktEnc.Nice] = noCKBytes[job.PktEnc.Nice] + job.Size
116                 }
117                 txNums := make(map[uint8]int)
118                 txBytes := make(map[uint8]int64)
119                 for job := range ctx.Jobs(node.Id, nncp.TTx) {
120                         if *showPkt {
121                                 jobPrint(nncp.TTx, job)
122                         }
123                         txNums[job.PktEnc.Nice] = txNums[job.PktEnc.Nice] + 1
124                         txBytes[job.PktEnc.Nice] = txBytes[job.PktEnc.Nice] + job.Size
125                 }
126                 var nice uint8
127                 for nice = 1; nice > 0; nice++ {
128                         rxNum, rxExists := rxNums[nice]
129                         txNum, txExists := txNums[nice]
130                         noCKNum, noCKExists := noCKNums[nice]
131                         if !(rxExists || txExists || noCKExists) {
132                                 continue
133                         }
134                         fmt.Printf(
135                                 "\tnice:% 4s | Rx: % 10s, % 3d pkts | Tx: % 10s, % 3d pkts",
136                                 nncp.NicenessFmt(nice),
137                                 humanize.IBytes(uint64(rxBytes[nice])),
138                                 rxNum,
139                                 humanize.IBytes(uint64(txBytes[nice])),
140                                 txNum,
141                         )
142                         if noCKExists {
143                                 fmt.Printf(
144                                         " | NoCK: % 10s, % 3d pkts",
145                                         humanize.IBytes(uint64(noCKBytes[nice])),
146                                         noCKNum,
147                                 )
148                         }
149                         fmt.Printf("\n")
150                 }
151         }
152 }