stats.go 4.5 K raw
1
package main
2
3
import (
4
	"encoding/json"
5
	"fmt"
6
	"io/ioutil"
7
	"net/http"
8
	"time"
9
10
	"github.com/shirou/gopsutil/cpu"
11
	"github.com/shirou/gopsutil/host"
12
	"github.com/shirou/gopsutil/mem"
13
)
14
15
func getStats() (CombinedStats, error) {
16
	repoStats, err := getIpfsRepoStat()
17
	if err != nil {
18
		return CombinedStats{}, err
19
	}
20
21
	bwStats, err := getBandwidthStats()
22
	if err != nil {
23
		return CombinedStats{}, err
24
	}
25
26
	radicleNodeStats, err := getRadicleStats()
27
	if err != nil {
28
		return CombinedStats{}, err
29
	}
30
31
	radicleRepoStats, err := getRadicleRepos()
32
	if err != nil {
33
		return CombinedStats{}, err
34
	}
35
36
	sysStats, err := getSystemStats()
37
	if err != nil {
38
		return CombinedStats{}, err
39
	}
40
41
	return CombinedStats{
42
		IPFSRepoStats:  repoStats,
43
		BandwidthStats: bwStats,
44
		SystemStats:    sysStats,
45
		RadNodeInfo:    radicleNodeStats,
46
		RadNodeRepos:   radicleRepoStats,
47
	}, nil
48
}
49
50
func getIpfsRepoStat() (IPFSRepoStats, error) {
51
	client := &http.Client{}
52
	req, err := http.NewRequest("POST", "http://127.0.0.1:5001/api/v0/repo/stat", nil)
53
	if err != nil {
54
		return IPFSRepoStats{}, fmt.Errorf("error creating request: %v", err)
55
	}
56
57
	resp, err := client.Do(req)
58
	if err != nil {
59
		return IPFSRepoStats{}, fmt.Errorf("error fetching IPFS Repo Stats: %v", err)
60
	}
61
	defer resp.Body.Close()
62
63
	body, err := ioutil.ReadAll(resp.Body)
64
	if err != nil {
65
		return IPFSRepoStats{}, fmt.Errorf("error reading response body: %v", err)
66
	}
67
68
	var stats IPFSRepoStats
69
	err = json.Unmarshal(body, &stats)
70
	if err != nil {
71
		return IPFSRepoStats{}, fmt.Errorf("error unmarshaling JSON: %v", err)
72
	}
73
74
	return stats, nil
75
}
76
77
func getBandwidthStats() (BandwidthStats, error) {
78
	client := &http.Client{}
79
	req, err := http.NewRequest("POST", "http://127.0.0.1:5001/api/v0/stats/bw", nil)
80
	if err != nil {
81
		return BandwidthStats{}, fmt.Errorf("error creating request: %v", err)
82
	}
83
84
	resp, err := client.Do(req)
85
	if err != nil {
86
		return BandwidthStats{}, fmt.Errorf("error fetching Bandwidth Stats: %v", err)
87
	}
88
	defer resp.Body.Close()
89
90
	body, err := ioutil.ReadAll(resp.Body)
91
	if err != nil {
92
		return BandwidthStats{}, fmt.Errorf("error reading response body: %v", err)
93
	}
94
95
	var stats BandwidthStats
96
	err = json.Unmarshal(body, &stats)
97
	if err != nil {
98
		return BandwidthStats{}, fmt.Errorf("error unmarshaling JSON: %v", err)
99
	}
100
101
	return stats, nil
102
}
103
104
func getRadicleStats() (RadNodeInfo, error) {
105
	client := &http.Client{}
106
	req, err := http.NewRequest("GET", "http://127.0.0.1:8888/api/v1/node", nil)
107
	if err != nil {
108
		return RadNodeInfo{}, fmt.Errorf("error creating request: %v", err)
109
	}
110
111
	resp, err := client.Do(req)
112
	if err != nil {
113
		return RadNodeInfo{}, fmt.Errorf("error fetching Rad Node Stats: %v", err)
114
	}
115
	defer resp.Body.Close()
116
117
	body, err := ioutil.ReadAll(resp.Body)
118
	if err != nil {
119
		return RadNodeInfo{}, fmt.Errorf("error reading response body: %v", err)
120
	}
121
122
	var stats RadNodeInfo
123
	err = json.Unmarshal(body, &stats)
124
	if err != nil {
125
		return RadNodeInfo{}, fmt.Errorf("error unmarshaling JSON: %v", err)
126
	}
127
128
	simplifiedStats := RadNodeInfo{
129
		ID:    stats.ID,
130
		Agent: stats.Agent,
131
		State: stats.State,
132
		Config: struct {
133
			SeedingPolicy struct {
134
				Default string `json:"default"`
135
			} `json:"seedingPolicy"`
136
		}{
137
			SeedingPolicy: stats.Config.SeedingPolicy,
138
		},
139
	}
140
141
	return simplifiedStats, nil
142
}
143
144
func getRadicleRepos() (RadNodeRepos, error) {
145
	client := &http.Client{}
146
	req, err := http.NewRequest("GET", "http://127.0.0.1:8888/api/v1/stats", nil)
147
	if err != nil {
148
		return RadNodeRepos{}, fmt.Errorf("error creating request: %v", err)
149
	}
150
151
	resp, err := client.Do(req)
152
	if err != nil {
153
		return RadNodeRepos{}, fmt.Errorf("error fetching Rad Node Stats: %v", err)
154
	}
155
	defer resp.Body.Close()
156
157
	body, err := ioutil.ReadAll(resp.Body)
158
	if err != nil {
159
		return RadNodeRepos{}, fmt.Errorf("error reading response body: %v", err)
160
	}
161
162
	var stats RadNodeRepos
163
	err = json.Unmarshal(body, &stats)
164
	if err != nil {
165
		return RadNodeRepos{}, fmt.Errorf("error unmarshaling JSON: %v", err)
166
	}
167
168
	return stats, nil
169
}
170
171
func getSystemStats() (SystemStats, error) {
172
	v, err := mem.VirtualMemory()
173
	if err != nil {
174
		return SystemStats{}, err
175
	}
176
177
	c, err := cpu.Percent(0, false)
178
	if err != nil {
179
		return SystemStats{}, err
180
	}
181
182
	hostInfo, err := host.Info()
183
	if err != nil {
184
		return SystemStats{}, err
185
	}
186
187
	uptime := time.Duration(hostInfo.Uptime) * time.Second
188
189
	return SystemStats{
190
		CPUUsage:    c[0],
191
		MemoryUsed:  v.Used,
192
		MemoryTotal: v.Total,
193
		OS:          "Debian GNU/Linux 12 (bookworm) aarch64",
194
		Kernel:      hostInfo.KernelVersion,
195
		Uptime:      FormatUptime(uptime),
196
		CPUModel:    "BCM2835 (4) @ 1.800GHz",
197
	}, nil
198
}