forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-08-17 09:23:48 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

dashboard: rename variables, use group declaration

Browse source
This commit is contained in:
Kurkó Mihály 2018-01-23 16:56:32 +02:00
parent f4b4204072
commit f95107fea0
6 changed files with 133 additions and 130 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

30
dashboard/assets.go
View file

@ -26509,12 +26509,12 @@ var _bundleJs = []byte((((((((((`!function(modules) {
home: { home: {
activeMemory: [], activeMemory: [],
virtualMemory: [], virtualMemory: [],
ingress: [], networkIngress: [],
egress: [], networkEgress: [],
processCPU: [], processCPU: [],
systemCPU: [], systemCPU: [],
read: [], diskRead: [],
write: [] diskWrite: []
}, },
chain: {}, chain: {},
txpool: {}, txpool: {},
@ -26531,12 +26531,12 @@ var _bundleJs = []byte((((((((((`!function(modules) {
home: { home: {
activeMemory: appender(200), activeMemory: appender(200),
virtualMemory: appender(200), virtualMemory: appender(200),
ingress: appender(200), networkIngress: appender(200),
egress: appender(200), networkEgress: appender(200),
processCPU: appender(200), processCPU: appender(200),
systemCPU: appender(200), systemCPU: appender(200),
read: appender(200), diskRead: appender(200),
write: appender(200) diskWrite: appender(200)
}, },
chain: null, chain: null,
txpool: null, txpool: null,
@ -31303,16 +31303,16 @@ var _bundleJs = []byte((((((((((`!function(modules) {
data: home.virtualMemory, data: home.virtualMemory,
tooltip: (0, _CustomTooltip.bytePlotter)("Virtual", (0, _CustomTooltip.multiplier)(-1)) tooltip: (0, _CustomTooltip.bytePlotter)("Virtual", (0, _CustomTooltip.multiplier)(-1))
}), this.doubleChart("all", { }), this.doubleChart("all", {
data: home.read, data: home.diskRead,
tooltip: (0, _CustomTooltip.bytePerSecPlotter)("Read") tooltip: (0, _CustomTooltip.bytePerSecPlotter)("Disk Read")
}, { }, {
data: home.write, data: home.diskWrite,
tooltip: (0, _CustomTooltip.bytePerSecPlotter)("Write", (0, _CustomTooltip.multiplier)(-1)) tooltip: (0, _CustomTooltip.bytePerSecPlotter)("Disk Write", (0, _CustomTooltip.multiplier)(-1))
}), this.doubleChart("all", { }), this.doubleChart("all", {
data: home.ingress, data: home.networkIngress,
tooltip: (0, _CustomTooltip.bytePerSecPlotter)("Download") tooltip: (0, _CustomTooltip.bytePerSecPlotter)("Download")
}, { }, {
data: home.egress, data: home.networkEgress,
tooltip: (0, _CustomTooltip.bytePerSecPlotter)("Upload", (0, _CustomTooltip.multiplier)(-1)) tooltip: (0, _CustomTooltip.bytePerSecPlotter)("Upload", (0, _CustomTooltip.multiplier)(-1))
}))), _react2.default.createElement(_Grid2.default, { }))), _react2.default.createElement(_Grid2.default, {
item: !0 item: !0
@ -38400,7 +38400,7 @@ func bundleJs() (*asset, error) {
} }
info := bindataFileInfo{name: "bundle.js", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} info := bindataFileInfo{name: "bundle.js", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x2d, 0x78, 0x89, 0xa1, 0x7d, 0x2e, 0xa5, 0xe0, 0xc, 0x68, 0x80, 0x26, 0x5, 0xa7, 0x37, 0x59, 0x73, 0xe6, 0xf2, 0xeb, 0x42, 0x9, 0xb6, 0x84, 0x1, 0x69, 0xb7, 0x23, 0x67, 0x42, 0x97, 0xa5}} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xc0, 0x90, 0x71, 0xbf, 0x69, 0x84, 0xe8, 0x63, 0x9a, 0x6c, 0x14, 0x49, 0xbd, 0x8b, 0x72, 0x2b, 0xe2, 0xd7, 0xdf, 0x49, 0x80, 0xea, 0x49, 0x2e, 0x7d, 0x4f, 0x23, 0x6b, 0xef, 0xcd, 0xc4, 0xdb}}
return a, nil return a, nil
} }

16
dashboard/assets/components/Dashboard.jsx
View file

@ -84,12 +84,12 @@ const defaultContent: Content = {
home: { home: {
activeMemory: [], activeMemory: [],
virtualMemory: [], virtualMemory: [],
ingress: [], networkIngress: [],
egress: [], networkEgress: [],
processCPU: [], processCPU: [],
systemCPU: [], systemCPU: [],
read: [], diskRead: [],
write: [], diskWrite: [],
}, },
chain: {}, chain: {},
txpool: {}, txpool: {},
@ -111,12 +111,12 @@ const updaters = {
home: { home: {
activeMemory: appender(200), activeMemory: appender(200),
virtualMemory: appender(200), virtualMemory: appender(200),
ingress: appender(200), networkIngress: appender(200),
egress: appender(200), networkEgress: appender(200),
processCPU: appender(200), processCPU: appender(200),
systemCPU: appender(200), systemCPU: appender(200),
read: appender(200), diskRead: appender(200),
write: appender(200), diskWrite: appender(200),
}, },
chain: null, chain: null,
txpool: null, txpool: null,

8
dashboard/assets/components/Footer.jsx
View file

@ -151,13 +151,13 @@ class Footer extends Component<Props> {
)} )}
{this.doubleChart( {this.doubleChart(
'all', 'all',
{data: home.read, tooltip: bytePerSecPlotter('Read')}, {data: home.diskRead, tooltip: bytePerSecPlotter('Disk Read')},
{data: home.write, tooltip: bytePerSecPlotter('Write', multiplier(-1))}, {data: home.diskWrite, tooltip: bytePerSecPlotter('Disk Write', multiplier(-1))},
)} )}
{this.doubleChart( {this.doubleChart(
'all', 'all',
{data: home.ingress, tooltip: bytePerSecPlotter('Download')}, {data: home.networkIngress, tooltip: bytePerSecPlotter('Download')},
{data: home.egress, tooltip: bytePerSecPlotter('Upload', multiplier(-1))}, {data: home.networkEgress, tooltip: bytePerSecPlotter('Upload', multiplier(-1))},
)} )}
</ChartRow> </ChartRow>
</Grid> </Grid>

8
dashboard/assets/types/content.jsx
View file

@ -34,12 +34,12 @@ export type General = {
export type Home = { export type Home = {
activeMemory: ChartEntries, activeMemory: ChartEntries,
virtualMemory: ChartEntries, virtualMemory: ChartEntries,
ingress: ChartEntries, networkIngress: ChartEntries,
egress: ChartEntries, networkEgress: ChartEntries,
processCPU: ChartEntries, processCPU: ChartEntries,
systemCPU: ChartEntries, systemCPU: ChartEntries,
read: ChartEntries, diskRead: ChartEntries,
write: ChartEntries, diskWrite: ChartEntries,
}; };
export type ChartEntries = Array<ChartEntry>; export type ChartEntries = Array<ChartEntry>;

145
dashboard/dashboard.go
View file

@ -46,12 +46,12 @@ import (
const ( const (
activeMemorySampleLimit = 200 // Maximum number of active memory data samples activeMemorySampleLimit = 200 // Maximum number of active memory data samples
virtualMemorySampleLimit = 200 // Maximum number of virtual memory data samples virtualMemorySampleLimit = 200 // Maximum number of virtual memory data samples
ingressSampleLimit = 200 // Maximum number of ingress data samples networkIngressSampleLimit = 200 // Maximum number of network ingress data samples
egressSampleLimit = 200 // Maximum number of egress data samples networkEgressSampleLimit = 200 // Maximum number of network egress data samples
processCPUSampleLimit = 200 // Maximum number of process cpu data samples processCPUSampleLimit = 200 // Maximum number of process cpu data samples
systemCPUSampleLimit = 200 // Maximum number of system cpu data samples systemCPUSampleLimit = 200 // Maximum number of system cpu data samples
readSampleLimit = 200 // Maximum number of read data samples diskReadSampleLimit = 200 // Maximum number of disk read data samples
writeSampleLimit = 200 // Maximum number of write data samples diskWriteSampleLimit = 200 // Maximum number of disk write data samples
) )
var nextID uint32 // Next connection id var nextID uint32 // Next connection id
@ -79,30 +79,31 @@ type client struct {
// New creates a new dashboard instance with the given configuration. // New creates a new dashboard instance with the given configuration.
func New(config *Config, commit string) (*Dashboard, error) { func New(config *Config, commit string) (*Dashboard, error) {
now := time.Now()
db := &Dashboard{ db := &Dashboard{
conns: make(map[uint32]*client), conns: make(map[uint32]*client),
config: config, config: config,
quit: make(chan chan error), quit: make(chan chan error),
charts: new(HomeMessage), charts: &HomeMessage{
ActiveMemory: emptyChartEntries(now, activeMemorySampleLimit, config.Refresh),
VirtualMemory: emptyChartEntries(now, virtualMemorySampleLimit, config.Refresh),
NetworkIngress: emptyChartEntries(now, networkIngressSampleLimit, config.Refresh),
NetworkEgress: emptyChartEntries(now, networkEgressSampleLimit, config.Refresh),
ProcessCPU: emptyChartEntries(now, processCPUSampleLimit, config.Refresh),
SystemCPU: emptyChartEntries(now, systemCPUSampleLimit, config.Refresh),
DiskRead: emptyChartEntries(now, diskReadSampleLimit, config.Refresh),
DiskWrite: emptyChartEntries(now, diskWriteSampleLimit, config.Refresh),
},
commit: commit, commit: commit,
} }
now := time.Now()
db.charts.ActiveMemory = db.emptyChartEntries(now, activeMemorySampleLimit)
db.charts.VirtualMemory = db.emptyChartEntries(now, virtualMemorySampleLimit)
db.charts.Ingress = db.emptyChartEntries(now, ingressSampleLimit)
db.charts.Egress = db.emptyChartEntries(now, egressSampleLimit)
db.charts.ProcessCPU = db.emptyChartEntries(now, processCPUSampleLimit)
db.charts.SystemCPU = db.emptyChartEntries(now, systemCPUSampleLimit)
db.charts.Read = db.emptyChartEntries(now, readSampleLimit)
db.charts.Write = db.emptyChartEntries(now, writeSampleLimit)
return db, nil return db, nil
} }
func (db *Dashboard) emptyChartEntries(t time.Time, limit int) ChartEntries { func emptyChartEntries(t time.Time, limit int, refresh time.Duration) ChartEntries {
ce := make(ChartEntries, limit) ce := make(ChartEntries, limit)
for i := 0; i < limit; i++ { for i := 0; i < limit; i++ {
ce[i] = &ChartEntry{ ce[i] = &ChartEntry{
Time: t.Add(-time.Duration(i) * db.config.Refresh), Time: t.Add(-time.Duration(i) * refresh),
} }
} }
return ce return ce
@ -242,12 +243,12 @@ func (db *Dashboard) apiHandler(conn *websocket.Conn) {
Home: &HomeMessage{ Home: &HomeMessage{
ActiveMemory: db.charts.ActiveMemory, ActiveMemory: db.charts.ActiveMemory,
VirtualMemory: db.charts.VirtualMemory, VirtualMemory: db.charts.VirtualMemory,
Ingress: db.charts.Ingress, NetworkIngress: db.charts.NetworkIngress,
Egress: db.charts.Egress, NetworkEgress: db.charts.NetworkEgress,
ProcessCPU: db.charts.ProcessCPU, ProcessCPU: db.charts.ProcessCPU,
SystemCPU: db.charts.SystemCPU, SystemCPU: db.charts.SystemCPU,
Read: db.charts.Read, DiskRead: db.charts.DiskRead,
Write: db.charts.Write, DiskWrite: db.charts.DiskWrite,
}, },
} }
// Start tracking the connection and drop at connection loss. // Start tracking the connection and drop at connection loss.
@ -272,17 +273,19 @@ func (db *Dashboard) apiHandler(conn *websocket.Conn) {
// collectData collects the required data to plot on the dashboard. // collectData collects the required data to plot on the dashboard.
func (db *Dashboard) collectData() { func (db *Dashboard) collectData() {
defer db.wg.Done() defer db.wg.Done()
prevIn := metrics.DefaultRegistry.Get("p2p/InboundTraffic").(metrics.Meter).Count()
prevOut := metrics.DefaultRegistry.Get("p2p/OutboundTraffic").(metrics.Meter).Count()
prevProcessCPUTime := getProcessCPUTime()
systemCPUUsage := gosigar.Cpu{} systemCPUUsage := gosigar.Cpu{}
systemCPUUsage.Get() systemCPUUsage.Get()
prevRead := metrics.DefaultRegistry.Get("eth/db/chaindata/compact/input").(metrics.Meter).Count() var (
prevWrite := metrics.DefaultRegistry.Get("eth/db/chaindata/compact/output").(metrics.Meter).Count() prevNetworkIngress = metrics.DefaultRegistry.Get("p2p/InboundTraffic").(metrics.Meter).Count()
prevNetworkEgress = metrics.DefaultRegistry.Get("p2p/OutboundTraffic").(metrics.Meter).Count()
prevProcessCPUTime = getProcessCPUTime()
prevSystemCPUUsage = systemCPUUsage
prevDiskRead = metrics.DefaultRegistry.Get("eth/db/chaindata/compact/input").(metrics.Meter).Count()
prevDiskWrite = metrics.DefaultRegistry.Get("eth/db/chaindata/compact/output").(metrics.Meter).Count()
frequency := float64(db.config.Refresh / time.Second) frequency = float64(db.config.Refresh / time.Second)
numCPU := float64(runtime.NumCPU()) numCPU = float64(runtime.NumCPU())
)
for { for {
select { select {
@ -290,34 +293,34 @@ func (db *Dashboard) collectData() {
errc <- nil errc <- nil
return return
case <-time.After(db.config.Refresh): case <-time.After(db.config.Refresh):
var mem runtime.MemStats
runtime.ReadMemStats(&mem)
curIn := metrics.DefaultRegistry.Get("p2p/InboundTraffic").(metrics.Meter).Count()
inboundTraffic := float64(curIn - prevIn)
prevIn = curIn
curOut := metrics.DefaultRegistry.Get("p2p/OutboundTraffic").(metrics.Meter).Count()
outboundTraffic := float64(curOut - prevOut)
prevOut = curOut
curProcessCPUTime := getProcessCPUTime()
processCPUTime := curProcessCPUTime - prevProcessCPUTime
prevProcessCPUTime = curProcessCPUTime
prevSystemCPUUsage := systemCPUUsage
systemCPUUsage.Get() systemCPUUsage.Get()
deltaCPU := systemCPUUsage.Delta(prevSystemCPUUsage) var (
curNetworkIngress = metrics.DefaultRegistry.Get("p2p/InboundTraffic").(metrics.Meter).Count()
curRead := metrics.DefaultRegistry.Get("eth/db/chaindata/compact/input").(metrics.Meter).Count() curNetworkEgress = metrics.DefaultRegistry.Get("p2p/OutboundTraffic").(metrics.Meter).Count()
deltaRead := curRead - prevRead curProcessCPUTime = getProcessCPUTime()
prevRead = curRead curSystemCPUUsage = systemCPUUsage
curDiskRead = metrics.DefaultRegistry.Get("eth/db/chaindata/compact/input").(metrics.Meter).Count()
curWrite := metrics.DefaultRegistry.Get("eth/db/chaindata/compact/output").(metrics.Meter).Count() curDiskWrite = metrics.DefaultRegistry.Get("eth/db/chaindata/compact/output").(metrics.Meter).Count()
deltaWrite := curWrite - prevWrite )
prevWrite = curWrite var (
deltaNetworkIngress = float64(curNetworkIngress - prevNetworkIngress)
deltaNetworkEgress = float64(curNetworkEgress - prevNetworkEgress)
deltaProcessCPUTime = curProcessCPUTime - prevProcessCPUTime
deltaSystemCPUUsage = systemCPUUsage.Delta(prevSystemCPUUsage)
deltaDiskRead = curDiskRead - prevDiskRead
deltaDiskWrite = curDiskWrite - prevDiskWrite
)
prevNetworkIngress = curNetworkIngress
prevNetworkEgress = curNetworkEgress
prevProcessCPUTime = curProcessCPUTime
prevSystemCPUUsage = curSystemCPUUsage
prevDiskRead = curDiskRead
prevDiskWrite = curDiskWrite
now := time.Now() now := time.Now()
var mem runtime.MemStats
runtime.ReadMemStats(&mem)
activeMemory := &ChartEntry{ activeMemory := &ChartEntry{
Time: now, Time: now,
Value: float64(mem.Alloc) / frequency, Value: float64(mem.Alloc) / frequency,
@ -326,49 +329,49 @@ func (db *Dashboard) collectData() {
Time: now, Time: now,
Value: float64(mem.Sys) / frequency, Value: float64(mem.Sys) / frequency,
} }
ingress := &ChartEntry{ networkIngress := &ChartEntry{
Time: now, Time: now,
Value: inboundTraffic / frequency, Value: deltaNetworkIngress / frequency,
} }
egress := &ChartEntry{ networkEgress := &ChartEntry{
Time: now, Time: now,
Value: outboundTraffic / frequency, Value: deltaNetworkEgress / frequency,
} }
processCPU := &ChartEntry{ processCPU := &ChartEntry{
Time: now, Time: now,
Value: processCPUTime / frequency / numCPU * 100, Value: deltaProcessCPUTime / frequency / numCPU * 100,
} }
systemCPU := &ChartEntry{ systemCPU := &ChartEntry{
Time: now, Time: now,
Value: float64(deltaCPU.Sys+deltaCPU.User) / frequency / numCPU, Value: float64(deltaSystemCPUUsage.Sys+deltaSystemCPUUsage.User) / frequency / numCPU,
} }
read := &ChartEntry{ diskRead := &ChartEntry{
Time: now, Time: now,
Value: float64(deltaRead) / frequency, Value: float64(deltaDiskRead) / frequency,
} }
write := &ChartEntry{ diskWrite := &ChartEntry{
Time: now, Time: now,
Value: float64(deltaWrite) / frequency, Value: float64(deltaDiskWrite) / frequency,
} }
db.charts.ActiveMemory = append(db.charts.ActiveMemory[1:], activeMemory) db.charts.ActiveMemory = append(db.charts.ActiveMemory[1:], activeMemory)
db.charts.VirtualMemory = append(db.charts.VirtualMemory[1:], virtualMemory) db.charts.VirtualMemory = append(db.charts.VirtualMemory[1:], virtualMemory)
db.charts.Ingress = append(db.charts.Ingress[1:], ingress) db.charts.NetworkIngress = append(db.charts.NetworkIngress[1:], networkIngress)
db.charts.Egress = append(db.charts.Egress[1:], egress) db.charts.NetworkEgress = append(db.charts.NetworkEgress[1:], networkEgress)
db.charts.ProcessCPU = append(db.charts.ProcessCPU[1:], processCPU) db.charts.ProcessCPU = append(db.charts.ProcessCPU[1:], processCPU)
db.charts.SystemCPU = append(db.charts.SystemCPU[1:], systemCPU) db.charts.SystemCPU = append(db.charts.SystemCPU[1:], systemCPU)
db.charts.Read = append(db.charts.Read[1:], read) db.charts.DiskRead = append(db.charts.DiskRead[1:], diskRead)
db.charts.Write = append(db.charts.Read[1:], write) db.charts.DiskWrite = append(db.charts.DiskRead[1:], diskWrite)
db.sendToAll(&Message{ db.sendToAll(&Message{
Home: &HomeMessage{ Home: &HomeMessage{
ActiveMemory: ChartEntries{activeMemory}, ActiveMemory: ChartEntries{activeMemory},
VirtualMemory: ChartEntries{virtualMemory}, VirtualMemory: ChartEntries{virtualMemory},
Ingress: ChartEntries{ingress}, NetworkIngress: ChartEntries{networkIngress},
Egress: ChartEntries{egress}, NetworkEgress: ChartEntries{networkEgress},
ProcessCPU: ChartEntries{processCPU}, ProcessCPU: ChartEntries{processCPU},
SystemCPU: ChartEntries{systemCPU}, SystemCPU: ChartEntries{systemCPU},
Read: ChartEntries{read}, DiskRead: ChartEntries{diskRead},
Write: ChartEntries{write}, DiskWrite: ChartEntries{diskWrite},
}, },
}) })
} }

8
dashboard/message.go
View file

@ -36,12 +36,12 @@ type GeneralMessage struct {
type HomeMessage struct { type HomeMessage struct {
ActiveMemory ChartEntries `json:"activeMemory,omitempty"` ActiveMemory ChartEntries `json:"activeMemory,omitempty"`
VirtualMemory ChartEntries `json:"virtualMemory,omitempty"` VirtualMemory ChartEntries `json:"virtualMemory,omitempty"`
Ingress ChartEntries `json:"ingress,omitempty"` NetworkIngress ChartEntries `json:"networkIngress,omitempty"`
Egress ChartEntries `json:"egress,omitempty"` NetworkEgress ChartEntries `json:"networkEgress,omitempty"`
ProcessCPU ChartEntries `json:"processCPU,omitempty"` ProcessCPU ChartEntries `json:"processCPU,omitempty"`
SystemCPU ChartEntries `json:"systemCPU,omitempty"` SystemCPU ChartEntries `json:"systemCPU,omitempty"`
Read ChartEntries `json:"read,omitempty"` DiskRead ChartEntries `json:"diskRead,omitempty"`
Write ChartEntries `json:"write,omitempty"` DiskWrite ChartEntries `json:"diskWrite,omitempty"`
} }
type ChartEntries []*ChartEntry type ChartEntries []*ChartEntry