Пример #1
0
func showStatus(s *rest.ServiceInfo) {
	d := time.Since(s.TimeStamp)
	// for printing second resolution is sufficient
	d -= d % time.Second
	fmt.Printf("%-20s %-10s  %10s    %s\n", s.Name,
		util.Status(s), util.FormatDuration(d), s.Status)
}
Пример #2
0
// update must be called with AppLock held.
func (i *InfoPanel) update() {

	s, e := i.app.GetItem(i.name)

	if i.info == s && i.err == e {
		return
	}
	i.info = s
	i.err = e
	words := []string{"[ESC] Main", "[H] Help"}

	i.titlebar.SetCenter("Details for " + i.name)

	if s == nil {
		if i.err != nil {
			i.statusbar.SetStatus(fmt.Sprintf(
				"No data: %v", i.err))
			i.statusbar.SetFail()
		} else {
			i.statusbar.SetStatus("Loading...")
			i.statusbar.SetNormal()
		}
		i.text.SetLines(nil)
		i.keybar.SetKeys(words)
		return
	}

	i.statusbar.SetStatus("")
	if !s.Enabled {
		i.statusbar.SetNormal()
	} else if s.Failed {
		i.statusbar.SetFail()
	} else if s.Running {
		i.statusbar.SetGood()
	} else {
		i.statusbar.SetWarn()
	}

	lines := make([]string, 0, 8)
	lines = append(lines, fmt.Sprintf("%13s %s", "Name:", s.Name))
	lines = append(lines, fmt.Sprintf("%13s %s", "Description:",
		s.Description))
	lines = append(lines, fmt.Sprintf("%13s %s", "Status:", util.Status(s)))
	lines = append(lines, fmt.Sprintf("%13s %v", "Since:", s.TimeStamp))
	lines = append(lines, fmt.Sprintf("%13s %s", "Detail:", s.Status))

	l := fmt.Sprintf("%13s", "Provides:")
	for _, p := range s.Provides {
		l = l + fmt.Sprintf(" %s", p)
	}
	lines = append(lines, l)

	l = fmt.Sprintf("%13s", "Depends:")
	for _, p := range s.Depends {
		l = l + fmt.Sprintf(" %s", p)
	}
	lines = append(lines, l)

	l = fmt.Sprintf("%13s", "Conflicts:")
	for _, p := range s.Conflicts {
		l = l + fmt.Sprintf(" %s", p)
	}
	lines = append(lines, l)

	i.text.SetLines(lines)

	words = append(words, "[L] Log")
	if !s.Enabled {
		words = append(words, "[E] Enable")
	} else {
		words = append(words, "[D] Disable")
		if s.Failed {
			words = append(words, "[C] Clear")
		}
		words = append(words, "[R] Restart")
	}
	i.keybar.SetKeys(words)
}
Пример #3
0
// update is called to update content, e.g. in response to Draw() or
// as part of another update.  It is called with the AppLock held.
func (m *MainPanel) update() {

	items, err := m.app.GetItems()
	m.items = items

	// preserve selected item
	if sel := m.selected; sel != nil {
		m.selected = nil
		cury := 0
		for _, item := range m.items {
			if item.Name == sel.Name {
				m.selected = item
				m.cury = cury
			}
			cury++
		}
	}
	if err != nil {
		m.statusbar.SetFail()
		m.statusbar.SetStatus(fmt.Sprintf("Cannot load items: %v", err))
		m.lines = []string{}
		m.styles = []topsl.Style{}
		return
	}

	lines := make([]string, 0, len(m.items))
	styles := make([]topsl.Style, 0, len(m.items))

	m.ndisabled = 0
	m.nfailed = 0
	m.nstopped = 0
	m.nrunning = 0

	m.height = 0
	m.width = 0

	for _, info := range items {
		d := time.Since(info.TimeStamp)
		d -= d % time.Second
		line := fmt.Sprintf("%-20s %-10s %10s   %-10s",
			info.Name, util.Status(info), util.FormatDuration(d),
			info.Status)

		if len(line) > m.width {
			m.width = len(line)
		}
		m.height++

		lines = append(lines, line)
		var style topsl.Style
		if !info.Enabled {
			style = topsl.StyleText
			m.ndisabled++
		} else if info.Failed {
			style = topsl.StyleError
			m.nfailed++
		} else if !info.Running {
			style = topsl.StyleWarn
			m.nstopped++
		} else {
			style = topsl.StyleGood
			m.nrunning++
		}
		styles = append(styles, style)
	}

	m.lines = lines
	m.styles = styles

	m.statusbar.SetStatus(fmt.Sprintf(
		"%6d Services %6d Faulted %6d Running %6d Standby %6d Disabled",
		len(m.items),
		m.nfailed, m.nrunning, m.nstopped, m.ndisabled))

	if m.nfailed > 0 {
		m.statusbar.SetFail()
	} else if m.nstopped > 0 {
		m.statusbar.SetWarn()
	} else if m.nrunning > 0 {
		m.statusbar.SetGood()
	} else {
		m.statusbar.SetNormal()
	}

	words := []string{"[Q] Quit", "[H] Help"}

	if item := m.selected; item != nil {
		words = append(words, "[I] Info")
		words = append(words, "[L] Log")
		if !item.Enabled {
			words = append(words, "[E] Enable")
		} else {
			words = append(words, "[D] Disable")
			if item.Failed {
				words = append(words, "[C] Clear")
			}
			words = append(words, "[R] Restart")
		}
	} else {
		words = append(words, "[L] Log")
	}
	m.keybar.SetKeys(words)
}
Пример #4
0
func main() {
	user := ""
	pass := ""
	logfile := ""
	cafile := ""
	capath := ""
	insecure := false

	flag.StringVar(&addr, "addr", addr, "govisor address")
	flag.StringVar(&user, "user", user, "user name for authentication")
	flag.StringVar(&pass, "pass", pass, "password for authentication")
	flag.StringVar(&cafile, "cacert", cafile, "CA certificate file")
	flag.StringVar(&capath, "capath", capath, "CA certificates directory")
	flag.StringVar(&logfile, "debuglog", logfile, "debug log file")
	flag.BoolVar(&insecure, "insecure", insecure, "allow insecure TLS connections")
	flag.Parse()

	var dlog *log.Logger
	if logfile != "" {
		f, e := os.Create(logfile)
		if e == nil {
			dlog = log.New(f, "DEBUG:", log.LstdFlags)
			log.SetOutput(f)
		}
	}

	roots := x509.NewCertPool()
	if cafile == "" && capath == "" {
		roots = nil
	} else {
		if cafile != "" {
			if e := loadCertFile(roots, cafile); e != nil {
				fatal("Unable to load cert file", e)
			}
		}
		if capath != "" {
			if e := loadCertPath(roots, capath); e != nil {
				fatal("Unable to load cert path", e)
			}
		}
	}

	u, e := url.Parse(addr)
	if e != nil {
		fatal("Bad address", e)
	}
	tcfg := &tls.Config{
		RootCAs:            roots,
		ServerName:         u.Host,
		InsecureSkipVerify: insecure,
	}
	tran := &http.Transport{
		TLSClientConfig: tcfg,
	}

	client := rest.NewClient(tran, addr)
	if user != "" || pass != "" {
		client.SetAuth(user, pass)
	}

	args := flag.Args()
	if len(args) == 0 {
		if e := doUI(client, addr, dlog); e != nil {
			// status by default
			args = []string{"status"}
		} else {
			return
		}
	}

	switch args[0] {
	case "services":
		if len(args) != 1 {
			usage()
		}
		s, e := client.Services()
		if e != nil {
			fatal("Error", e)
		}
		sort.Strings(s)
		for _, name := range s {
			fmt.Println(name)
		}
	case "enable":
		if len(args) != 2 {
			usage()
		}
		e := client.EnableService(args[1])
		if e != nil {
			fatal("Error", e)
		}
	case "disable":
		if len(args) != 2 {
			usage()
		}
		e := client.DisableService(args[1])
		if e != nil {
			fatal("Error", e)
		}

	case "restart":
		if len(args) != 2 {
			usage()
		}
		e := client.RestartService(args[1])
		if e != nil {
			fatal("Error", e)
		}

	case "clear":
		if len(args) != 2 {
			usage()
		}
		e := client.ClearService(args[1])
		if e != nil {
			fatal("Error", e)
		}

	case "log":
		loginfo := &rest.LogInfo{}
		switch len(args) {
		case 0:
			usage()
		case 1:
			loginfo, e = client.GetLog("")
		case 2:
			loginfo, e = client.GetLog(args[1])
		}
		if e != nil {
			fatal("Error", e)
		}
		for _, line := range loginfo.Records {
			fmt.Printf("%s %s\n",
				line.Time.Format(time.StampMilli), line.Text)
		}
	case "info":
		if len(args) != 2 {
			usage()
		}
		s, e := client.GetService(args[1])
		if e != nil {
			fatal("Failed", e)
		}
		fmt.Printf("Name:      %s\n", s.Name)
		fmt.Printf("Desc:      %s\n", s.Description)
		fmt.Printf("Status:    %s\n", util.Status(s))
		fmt.Printf("Since:     %v\n", time.Now().Sub(s.TimeStamp))
		fmt.Printf("Detail:    %s\n", s.Status)
		fmt.Printf("Provides: ")
		for _, p := range s.Provides {
			fmt.Printf(" %s", p)
		}
		fmt.Printf("\n")
		fmt.Printf("Depends:   ")
		for _, p := range s.Depends {
			fmt.Printf(" %s", p)
		}
		fmt.Printf("\n")
		fmt.Printf("Conflicts: ")
		for _, p := range s.Conflicts {
			fmt.Printf(" %s", p)
		}
		fmt.Printf("\n")
	case "status":
		names := args[1:]
		var e error
		if len(names) == 0 {
			names, e = client.Services()
			if e != nil {
				fatal("Error", e)
			}
		}
		if len(names) == 0 {
			// No services?
			return
		}
		infos := []*rest.ServiceInfo{}
		for _, n := range names {
			info, e := client.GetService(n)
			if e == nil {
				infos = append(infos, info)
			} else {
				fatal("Error", e)
			}
		}
		util.SortServices(infos)
		for _, info := range infos {
			showStatus(info)
		}
	case "ui":
		if e := doUI(client, addr, dlog); e != nil {
			fatal("Error", e)
		}
	}
}