func (this *Clusters) printSummary(zkzone *zk.ZkZone, clusterPattern string, port string) {
lines := []string{"Zone|Cluster|Brokers|Topics|Partitions|FlatMsg|Cum"}
type summary struct {
zone, cluster string
brokers, topics, partitions int
flat, cum int64
}
summaries := make([]summary, 0, 10)
zkzone.ForSortedClusters(func(zkcluster *zk.ZkCluster) {
if !patternMatched(zkcluster.Name(), clusterPattern) {
return
}
brokers, topics, partitions, flat, cum := this.clusterSummary(zkcluster)
summaries = append(summaries, summary{zkzone.Name(), zkcluster.Name(), brokers, topics, partitions,
flat, cum})
})
sortutil.DescByField(summaries, "cum")
var totalFlat, totalCum int64
for _, s := range summaries {
lines = append(lines, fmt.Sprintf("%s|%s|%d|%d|%d|%s|%s",
s.zone, s.cluster, s.brokers, s.topics, s.partitions,
gofmt.Comma(s.flat), gofmt.Comma(s.cum)))
totalCum += s.cum
totalFlat += s.flat
}
this.Ui.Output(columnize.SimpleFormat(lines))
this.Ui.Output(fmt.Sprintf("Flat:%s Cum:%s", gofmt.Comma(totalFlat), gofmt.Comma(totalCum)))
}
func decodeEventStdin(data string) *EventWatch {
var events []EventWatch
err := json.Unmarshal([]byte(data), &events)
if err != nil {
Log(fmt.Sprintf("error: %s", data), "info")
os.Exit(1)
}
sortutil.DescByField(events, "LTime")
event := events[0]
return &event
}
func drawDashboardByUser() {
lock.Lock()
commitByUsers := make(map[string]int)
for _, evt := range events {
if hook, ok := evt.(*Webhook); ok {
for _, c := range hook.Commits {
key := fmt.Sprintf("%s %s", c.Author.Name, c.Author.Email)
if _, present := commitByUsers[key]; !present {
commitByUsers[key] = 1
} else {
commitByUsers[key] += 1
}
}
}
}
lock.Unlock()
type user struct {
name string
commits int
}
users := make([]user, 0, len(commitByUsers))
for name, n := range commitByUsers {
users = append(users, user{name: name, commits: n})
}
sortutil.DescByField(users, "commits")
termbox.Clear(coldef, coldef)
y := 0
for i, u := range users {
row := fmt.Sprintf("%s: %5d", wideStr(u.name, 60), u.commits)
drawRow(row, y, coldef, coldef)
y++
if i >= h {
break
}
}
termbox.Flush()
}
func CmdList(myUsersID string, iu IUsers, ii invites.IInvites) error {
orgUsers, err := iu.List()
if err != nil {
return err
}
if orgUsers == nil || len(*orgUsers) == 0 {
logrus.Println("No users found")
return nil
}
roles, err := ii.ListRoles()
if err != nil {
return err
}
rolesMap := map[int]string{}
for _, r := range *roles {
rolesMap[r.ID] = r.Name
}
sortutil.DescByField(*orgUsers, "RoleID")
data := [][]string{{"EMAIL", "ROLE"}}
for _, user := range *orgUsers {
if user.ID == myUsersID {
data = append(data, []string{user.Email, fmt.Sprintf("%s (you)", rolesMap[user.RoleID])})
} else {
data = append(data, []string{user.Email, rolesMap[user.RoleID]})
}
}
table := tablewriter.NewWriter(logrus.StandardLogger().Out)
table.SetBorder(false)
table.SetRowLine(false)
table.SetCenterSeparator("")
table.SetColumnSeparator("")
table.SetRowSeparator("")
table.AppendBulk(data)
table.Render()
return nil
}
func drawDashboardByProject() {
lock.Lock()
commitByProjects := make(map[string]int)
for _, evt := range events {
if hook, ok := evt.(*Webhook); ok {
if _, present := commitByProjects[hook.Repository.Homepage]; !present {
commitByProjects[hook.Repository.Homepage] = hook.Total_commits_count
} else {
commitByProjects[hook.Repository.Homepage] += hook.Total_commits_count
}
}
}
lock.Unlock()
type project struct {
name string
commits int
}
projects := make([]project, 0, len(commitByProjects))
for name, n := range commitByProjects {
projects = append(projects, project{name: name, commits: n})
}
sortutil.DescByField(projects, "commits")
termbox.Clear(coldef, coldef)
y := 0
for i, p := range projects {
row := fmt.Sprintf("%80s: %5d", p.name, p.commits)
drawRow(row, y, coldef, coldef)
y++
if i >= h {
break
}
}
termbox.Flush()
}
func (this *Topics) printSummary(zkzone *zk.ZkZone, clusterPattern string) {
lines := []string{"Zone|Cluster|Topic|Partitions|FlatMsg|Cum"}
var totalFlat, totalCum int64
zkzone.ForSortedClusters(func(zkcluster *zk.ZkCluster) {
if !patternMatched(zkcluster.Name(), clusterPattern) {
return
}
summaries := this.clusterSummary(zkcluster)
sortutil.DescByField(summaries, "cum")
for _, s := range summaries {
lines = append(lines, fmt.Sprintf("%s|%s|%s|%d|%s|%s",
s.zone, s.cluster, s.topic, s.partitions, gofmt.Comma(s.flat), gofmt.Comma(s.cum)))
totalCum += s.cum
totalFlat += s.flat
}
})
this.Ui.Output(columnize.SimpleFormat(lines))
this.Ui.Output(fmt.Sprintf("Flat:%s Cum:%s", gofmt.Comma(totalFlat), gofmt.Comma(totalCum)))
}
func (this *Redis) render() {
if !this.batchMode {
termbox.Clear(termbox.ColorDefault, termbox.ColorDefault)
}
this.mu.Lock()
defer this.mu.Unlock()
if this.topOrderAsc {
sortutil.AscByField(this.topInfos, this.topOrderCols[this.topOrderColIdx])
} else {
sortutil.DescByField(this.topInfos, this.topOrderCols[this.topOrderColIdx])
}
sortCols := make([]string, len(this.topOrderCols))
copy(sortCols, this.topOrderCols)
for i, col := range sortCols {
if col == this.selectedCol() {
if this.topOrderAsc {
sortCols[i] += " >"
} else {
sortCols[i] += " <"
}
}
}
var (
lines = []string{fmt.Sprintf("Host|Port|%s", strings.Join(sortCols, "|"))}
sumDbsize, sumConns, sumOps, sumMem, sumRx, sumTx, sumMaxMem int64
)
for i := 0; i < len(this.topInfos); i++ {
info := this.topInfos[i]
sumDbsize += info.dbsize
sumConns += info.conns
sumOps += info.ops
sumMem += info.mem
sumMaxMem += info.maxmem
sumRx += info.rx * 1024 / 8
sumTx += info.tx * 1024 / 8
if info.ops >= this.beep {
this.warnPorts[strconv.Itoa(info.port)] = struct{}{}
}
this.maxDbSize = max(this.maxDbSize, info.dbsize)
this.maxConns = max(this.maxConns, info.conns)
this.maxOps = max(this.maxOps, info.ops)
this.maxMem = max(this.maxMem, info.mem)
this.maxMaxMem = max(this.maxMaxMem, info.maxmem)
this.maxRx = max(this.maxRx, info.rx*1024/8)
this.maxTx = max(this.maxTx, info.tx*1024/8)
if info.memp > this.maxMemp {
this.maxMemp = info.memp
}
if info.trp > this.maxTrp {
this.maxTrp = info.trp
}
if i >= min(this.rows, len(this.topInfos)) {
continue
}
l := fmt.Sprintf("%s|%d|%s|%s|%s|%s|%s|%6.1f|%s|%s|%8.1f",
info.host, info.port,
gofmt.Comma(info.dbsize), gofmt.Comma(info.conns), gofmt.Comma(info.ops),
gofmt.ByteSize(info.mem), gofmt.ByteSize(info.maxmem),
100.*info.memp,
gofmt.ByteSize(info.rx*1024/8), gofmt.ByteSize(info.tx*1024/8),
info.trp)
if this.beep > 0 {
var val int64
switch this.selectedCol() {
case "conns":
val = info.conns
case "rx":
val = info.rx
case "tx":
val = info.tx
case "dbsize":
val = info.dbsize
case "ops":
val = info.ops
case "mem":
val = info.mem
case "maxm":
val = info.maxmem
}
if val > this.beep {
//l += "\a"
}
}
lines = append(lines, l)
}
lines = append(lines, fmt.Sprintf("-MAX-|%d|%s|%s|%s|%s|%s|%6.1f|%s|%s|%8.1f",
len(this.topInfos),
gofmt.Comma(this.maxDbSize), gofmt.Comma(this.maxConns), gofmt.Comma(this.maxOps),
gofmt.ByteSize(this.maxMem), gofmt.ByteSize(this.maxMaxMem),
100.*this.maxMemp,
gofmt.ByteSize(this.maxRx), gofmt.ByteSize(this.maxTx),
this.maxTrp))
lines = append(lines, fmt.Sprintf("-TOTAL-|%d|%s|%s|%s|%s|%s|%6.1f|%s|%s|%8.1f",
len(this.topInfos),
gofmt.Comma(sumDbsize), gofmt.Comma(sumConns), gofmt.Comma(sumOps),
gofmt.ByteSize(sumMem), gofmt.ByteSize(sumMaxMem),
100.*float64(sumMem)/float64(sumMaxMem),
gofmt.ByteSize(sumRx), gofmt.ByteSize(sumTx),
float64(sumTx)/float64(sumRx)))
for row, line := range lines {
if row == 0 {
// header
this.drawRow(line, row, termbox.ColorDefault, termbox.ColorBlue)
} else if row == len(lines)-2 {
// max line
this.drawRow(line, row, termbox.ColorMagenta, termbox.ColorDefault)
} else if row == len(lines)-1 {
// total line
this.drawRow(line, row, termbox.ColorYellow, termbox.ColorDefault)
} else {
tuples := strings.Split(line, "|")
if _, present := this.selectedPorts[tuples[1]]; present {
this.drawRow(line, row, termbox.ColorBlack, termbox.ColorCyan)
} else if _, present := this.warnPorts[tuples[1]]; !present {
this.drawRow(line, row, termbox.ColorDefault, termbox.ColorDefault)
} else {
this.drawRow(line, row, termbox.ColorDefault, termbox.ColorRed)
}
}
}
if !this.batchMode {
termbox.Flush()
}
}
func GetRange(start string, end string, interval float64, page int) ([]*ValueDP, error) {
data, err := redis.Strings(rds.Do("KEYSRANGE", start, end))
if err != nil {
return nil, err
}
if len(data) <= 0 {
return nil, errors.New("no data")
}
sortutil.Desc(data)
var IntervalData []string
for _, v := range data {
if len(IntervalData) == 0 {
IntervalData = append(IntervalData, v)
} else {
otime := strings.Split(IntervalData[len(IntervalData)-1], ",")
otm, _ := time.Parse(time.RFC3339Nano, otime[3])
vtime := strings.Split(v, ",")
vtm, _ := time.Parse(time.RFC3339Nano, vtime[3])
du := otm.Sub(vtm)
if du.Seconds() >= interval {
IntervalData = append(IntervalData, v)
}
}
}
pageSize := 50
allcount := len(IntervalData)
lastPageSize := allcount % pageSize
totalPage := (allcount + pageSize - 1) / pageSize
if page > totalPage {
return nil, errors.New("pages out of range")
}
var pageData []string
if page == 1 {
if totalPage == page {
//只有一页
pageData = IntervalData[:allcount]
} else {
//不止一页的第一页
pageData = IntervalData[:pageSize]
}
} else if page < totalPage {
//中间页
cursor := (pageSize * page) - pageSize //起启位计算
pageData = IntervalData[cursor : cursor+pageSize]
} else if page == totalPage {
//尾页
if lastPageSize == 0 {
pageData = IntervalData[allcount-pageSize:]
} else {
pageData = IntervalData[allcount-lastPageSize:]
}
} else {
return nil, errors.New("page not ext")
}
var ndata []*ValueDP
for _, v := range pageData {
o, _ := redis.String(rds.Do("GET", v))
h := &ValueDP{}
json.Unmarshal([]byte(o), &h)
ndata = append(ndata, h)
}
sortutil.DescByField(ndata, "TimeStamp")
return ndata, nil
}
func (self *Querys) Sort() {
sortutil.DescByField(self, "Freq")
}