mirror of https://github.com/edouardparis/lntop
You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
263 lines
6.4 KiB
Go
263 lines
6.4 KiB
Go
package views
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
"github.com/jroimartin/gocui"
|
|
"golang.org/x/text/language"
|
|
"golang.org/x/text/message"
|
|
|
|
netModels "github.com/edouardparis/lntop/network/models"
|
|
"github.com/edouardparis/lntop/ui/color"
|
|
"github.com/edouardparis/lntop/ui/models"
|
|
)
|
|
|
|
const (
|
|
CHANNEL = "channel"
|
|
CHANNEL_HEADER = "channel_header"
|
|
CHANNEL_FOOTER = "channel_footer"
|
|
)
|
|
|
|
type Channel struct {
|
|
view *gocui.View
|
|
channels *models.Channels
|
|
}
|
|
|
|
func (c Channel) Name() string {
|
|
return CHANNEL
|
|
}
|
|
|
|
func (c Channel) Empty() bool {
|
|
return c.channels == nil
|
|
}
|
|
|
|
func (c *Channel) Wrap(v *gocui.View) View {
|
|
c.view = v
|
|
return c
|
|
}
|
|
|
|
func (c Channel) Origin() (int, int) {
|
|
return c.view.Origin()
|
|
}
|
|
|
|
func (c Channel) Cursor() (int, int) {
|
|
return c.view.Cursor()
|
|
}
|
|
|
|
func (c Channel) Speed() (int, int, int, int) {
|
|
return 1, 1, 1, 1
|
|
}
|
|
|
|
func (c Channel) Limits() (pageSize int, fullSize int) {
|
|
_, pageSize = c.view.Size()
|
|
fullSize = len(c.view.BufferLines()) - 1
|
|
return
|
|
}
|
|
|
|
func (c *Channel) SetCursor(x, y int) error {
|
|
return c.view.SetCursor(x, y)
|
|
}
|
|
|
|
func (c *Channel) SetOrigin(x, y int) error {
|
|
return c.view.SetOrigin(x, y)
|
|
}
|
|
|
|
func (c *Channel) Set(g *gocui.Gui, x0, y0, x1, y1 int) error {
|
|
header, err := g.SetView(CHANNEL_HEADER, x0-1, y0, x1+2, y0+2)
|
|
if err != nil {
|
|
if err != gocui.ErrUnknownView {
|
|
return err
|
|
}
|
|
}
|
|
header.Frame = false
|
|
header.BgColor = gocui.ColorGreen
|
|
header.FgColor = gocui.ColorBlack | gocui.AttrBold
|
|
header.Clear()
|
|
fmt.Fprintln(header, "Channel")
|
|
|
|
v, err := g.SetView(CHANNEL, x0-1, y0+1, x1+2, y1-1)
|
|
if err != nil {
|
|
if err != gocui.ErrUnknownView {
|
|
return err
|
|
}
|
|
}
|
|
v.Frame = false
|
|
c.view = v
|
|
c.display()
|
|
|
|
footer, err := g.SetView(CHANNEL_FOOTER, x0-1, y1-2, x1, y1)
|
|
if err != nil {
|
|
if err != gocui.ErrUnknownView {
|
|
return err
|
|
}
|
|
}
|
|
footer.Frame = false
|
|
footer.BgColor = gocui.ColorCyan
|
|
footer.FgColor = gocui.ColorBlack
|
|
footer.Clear()
|
|
blackBg := color.Black(color.Background)
|
|
fmt.Fprintf(footer, "%s%s %s%s %s%s %s%s\n",
|
|
blackBg("F2"), "Menu",
|
|
blackBg("Enter"), "Channels",
|
|
blackBg("C"), "Get disabled",
|
|
blackBg("F10"), "Quit",
|
|
)
|
|
return nil
|
|
}
|
|
|
|
func (c Channel) Delete(g *gocui.Gui) error {
|
|
err := g.DeleteView(CHANNEL_HEADER)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
err = g.DeleteView(CHANNEL)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return g.DeleteView(CHANNEL_FOOTER)
|
|
}
|
|
|
|
func printPolicy(v *gocui.View, p *message.Printer, policy *netModels.RoutingPolicy, outgoing bool) {
|
|
green := color.Green()
|
|
cyan := color.Cyan()
|
|
red := color.Red()
|
|
fmt.Fprintln(v, "")
|
|
direction := "Outgoing"
|
|
if !outgoing {
|
|
direction = "Incoming"
|
|
}
|
|
fmt.Fprintf(v, green(" [ %s Policy ]\n"), direction)
|
|
if policy.Disabled {
|
|
fmt.Fprintln(v, red("disabled"))
|
|
}
|
|
fmt.Fprintf(v, "%s %d\n",
|
|
cyan(" Time lock delta:"), policy.TimeLockDelta)
|
|
fmt.Fprintf(v, "%s %s\n",
|
|
cyan(" Min htlc (msat):"), formatAmount(policy.MinHtlc))
|
|
fmt.Fprintf(v, "%s %s\n",
|
|
cyan(" Max htlc (sat):"), formatAmount(int64(policy.MaxHtlc/1000)))
|
|
fmt.Fprintf(v, "%s %s\n",
|
|
cyan(" Fee base msat:"), formatAmount(policy.FeeBaseMsat))
|
|
fmt.Fprintf(v, "%s %d\n",
|
|
cyan(" Fee rate milli msat:"), policy.FeeRateMilliMsat)
|
|
}
|
|
|
|
func formatAmount(amt int64) string {
|
|
btc := amt / 1e8
|
|
ms := amt % 1e8 / 1e6
|
|
ts := amt % 1e6 / 1e3
|
|
s := amt % 1e3
|
|
if btc > 0 {
|
|
return fmt.Sprintf("%d.%02d,%03d,%03d", btc, ms, ts, s)
|
|
}
|
|
if ms > 0 {
|
|
return fmt.Sprintf("%d,%03d,%03d", ms, ts, s)
|
|
}
|
|
if ts > 0 {
|
|
return fmt.Sprintf("%d,%03d", ts, s)
|
|
}
|
|
if s >= 0 {
|
|
return fmt.Sprintf("%d", s)
|
|
}
|
|
return fmt.Sprintf("error: %d", amt)
|
|
}
|
|
|
|
func formatDisabledCount(cnt int, total uint32) string {
|
|
perc := uint32(cnt) * 100 / total
|
|
disabledStr := ""
|
|
if perc >= 25 && perc < 50 {
|
|
disabledStr = color.Yellow(color.Bold)(fmt.Sprintf("%4d", cnt))
|
|
} else if perc >= 50 {
|
|
disabledStr = color.Red(color.Bold)(fmt.Sprintf("%4d", cnt))
|
|
} else {
|
|
disabledStr = fmt.Sprintf("%4d", cnt)
|
|
}
|
|
return fmt.Sprintf("%s / %d (%d%%)", disabledStr, total, perc)
|
|
}
|
|
|
|
func (c *Channel) display() {
|
|
p := message.NewPrinter(language.English)
|
|
v := c.view
|
|
v.Clear()
|
|
channel := c.channels.Current()
|
|
green := color.Green()
|
|
cyan := color.Cyan()
|
|
fmt.Fprintln(v, green(" [ Channel ]"))
|
|
fmt.Fprintf(v, "%s %s\n",
|
|
cyan(" Status:"), status(channel))
|
|
fmt.Fprintf(v, "%s %d (%s)\n",
|
|
cyan(" ID:"), channel.ID, ToScid(channel.ID))
|
|
fmt.Fprintf(v, "%s %s\n",
|
|
cyan(" Capacity:"), formatAmount(channel.Capacity))
|
|
fmt.Fprintf(v, "%s %s\n",
|
|
cyan(" Local Balance:"), formatAmount(channel.LocalBalance))
|
|
fmt.Fprintf(v, "%s %s\n",
|
|
cyan(" Remote Balance:"), formatAmount(channel.RemoteBalance))
|
|
fmt.Fprintf(v, "%s %s\n",
|
|
cyan(" Channel Point:"), channel.ChannelPoint)
|
|
fmt.Fprintln(v, "")
|
|
fmt.Fprintln(v, green(" [ Node ]"))
|
|
fmt.Fprintf(v, "%s %s\n",
|
|
cyan(" PubKey:"), channel.RemotePubKey)
|
|
|
|
if channel.Node != nil {
|
|
alias, forced := channel.ShortAlias()
|
|
if forced {
|
|
alias = cyan(alias)
|
|
}
|
|
fmt.Fprintf(v, "%s %s\n",
|
|
cyan(" Alias:"), alias)
|
|
fmt.Fprintf(v, "%s %s\n",
|
|
cyan(" Total Capacity:"), formatAmount(channel.Node.TotalCapacity))
|
|
fmt.Fprintf(v, "%s %d\n",
|
|
cyan(" Total Channels:"), channel.Node.NumChannels)
|
|
|
|
if c.channels.CurrentNode != nil && c.channels.CurrentNode.PubKey == channel.RemotePubKey {
|
|
disabledOut := 0
|
|
disabledIn := 0
|
|
for _, ch := range c.channels.CurrentNode.Channels {
|
|
if ch.Policy1 != nil && ch.Policy1.Disabled {
|
|
disabledOut++
|
|
}
|
|
if ch.Policy2 != nil && ch.Policy2.Disabled {
|
|
disabledIn++
|
|
}
|
|
}
|
|
fmt.Fprintf(v, "\n %s %s\n", cyan("Disabled from node:"), formatDisabledCount(disabledOut, channel.Node.NumChannels))
|
|
fmt.Fprintf(v, " %s %s\n", cyan("Disabled to node: "), formatDisabledCount(disabledIn, channel.Node.NumChannels))
|
|
}
|
|
}
|
|
|
|
if channel.Policy1 != nil && channel.WeFirst {
|
|
printPolicy(v, p, channel.Policy1, true)
|
|
}
|
|
|
|
if channel.Policy2 != nil {
|
|
printPolicy(v, p, channel.Policy2, !channel.WeFirst)
|
|
}
|
|
|
|
if channel.Policy1 != nil && !channel.WeFirst {
|
|
printPolicy(v, p, channel.Policy1, false)
|
|
}
|
|
if len(channel.PendingHTLC) > 0 {
|
|
fmt.Fprintln(v)
|
|
fmt.Fprintln(v, green(" [ Pending HTLCs ]"))
|
|
for _, htlc := range channel.PendingHTLC {
|
|
fmt.Fprintf(v, "%s %t\n",
|
|
cyan(" Incoming:"), htlc.Incoming)
|
|
fmt.Fprintf(v, "%s %s\n",
|
|
cyan(" Amount:"), formatAmount(htlc.Amount))
|
|
fmt.Fprintf(v, "%s %d\n",
|
|
cyan(" Expiration:"), htlc.ExpirationHeight)
|
|
fmt.Fprintln(v)
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
func NewChannel(channels *models.Channels) *Channel {
|
|
return &Channel{channels: channels}
|
|
}
|