Beispiel #1
0
// printStatus pretty prints a status message
func printStatus(L *lua.LState) int {
	w, _, err := terminal.GetSize(int(os.Stdout.Fd()))
	if err != nil {
		emit("Unable to get terminal size: %v", err)
		return 0
	}
	reset := "\033[0m"
	red := "\033[31m"
	green := "\033[32m"
	blue := "\033[34m"

	status := fmt.Sprintf("[%vudef%v]", blue, reset)
	ok := fmt.Sprintf("[ %vok%v ]", green, reset)
	fail := fmt.Sprintf("[%vfail%v]", red, reset)
	switch L.Get(2).Type() {
	case lua.LTBool:
		status = fail
		if L.ToBool(2) {
			status = ok
		}
	case lua.LTNumber:
		status = fail
		if L.ToInt(2) == 0 {
			status = ok
		}
	}

	message := L.ToString(1)
	fmt.Printf("%v%v%v\n", message, strings.Repeat(" ", w-len(message)-len(status)+len(reset)+len(red)-1), status)

	return 0
}
Beispiel #2
0
func (cmd CmdCheck) newReadProgress(todo restic.Stat) *restic.Progress {
	if !cmd.global.ShowProgress() {
		return nil
	}

	readProgress := restic.NewProgress(time.Second)

	readProgress.OnUpdate = func(s restic.Stat, d time.Duration, ticker bool) {
		status := fmt.Sprintf("[%s] %s  %d / %d items",
			formatDuration(d),
			formatPercent(s.Blobs, todo.Blobs),
			s.Blobs, todo.Blobs)

		w, _, err := terminal.GetSize(int(os.Stdout.Fd()))
		if err == nil {
			if len(status) > w {
				max := w - len(status) - 4
				status = status[:max] + "... "
			}
		}

		fmt.Printf("\x1b[2K%s\r", status)
	}

	readProgress.OnDone = func(s restic.Stat, d time.Duration, ticker bool) {
		fmt.Printf("\nduration: %s\n", formatDuration(d))
	}

	return readProgress
}
Beispiel #3
0
func runAttached(c *cli.Context, app, ps, args, release string) (int, error) {
	fd := os.Stdin.Fd()

	var w, h int

	if terminal.IsTerminal(int(fd)) {
		stdinState, err := terminal.GetState(int(fd))
		if err != nil {
			return -1, err
		}

		defer terminal.Restore(int(fd), stdinState)

		w, h, err = terminal.GetSize(int(fd))
		if err != nil {
			return -1, err
		}
	}

	code, err := rackClient(c).RunProcessAttached(app, ps, args, release, h, w, os.Stdin, os.Stdout)
	if err != nil {
		return -1, err
	}

	return code, nil
}
Beispiel #4
0
func (p *pullProgress) SetProgress(cur, max int, msg string) {
	cols, _, err := terminal.GetSize(0)
	if err != nil {
		format := fmt.Sprintf("%%%dd", len(fmt.Sprintf("%d", max)))
		fmt.Printf(format+"/%d %s\n", cur, max, msg)
	} else {
		if p.first {
			p.first = false
		} else if p.verbose {
			fmt.Printf("\x1b[2A\x1b[K%s\n", p.lastmsg)
		} else {
			fmt.Print("\x1b[2A")
		}
		percent := fmt.Sprintf("%d%%", 100*cur/max)
		ratio := fmt.Sprintf("%d/%d", cur, max)
		progresssize := cols - len(percent) - 2
		psz1 := progresssize * cur / max
		psz2 := progresssize - psz1
		progress := strings.Repeat("#", psz1) + strings.Repeat("-", psz2)
		msglen := cols - len(ratio) - 2
		if len(msg) > msglen {
			msg = msg[:msglen]
		}
		p.lastmsg = fmt.Sprintf("%s %s", ratio, msg)
		fmt.Printf("\x1b[K%s %s\n\x1b[K%s\n", percent, progress, p.lastmsg)
	}
}
Beispiel #5
0
// newProgressMax returns a progress that counts blobs.
func newProgressMax(show bool, max uint64, description string) *restic.Progress {
	if !show {
		return nil
	}

	p := restic.NewProgress()

	p.OnUpdate = func(s restic.Stat, d time.Duration, ticker bool) {
		status := fmt.Sprintf("[%s] %s  %d / %d %s",
			formatDuration(d),
			formatPercent(s.Blobs, max),
			s.Blobs, max, description)

		w, _, err := terminal.GetSize(int(os.Stdout.Fd()))
		if err == nil {
			if len(status) > w {
				max := w - len(status) - 4
				status = status[:max] + "... "
			}
		}

		PrintProgress("%s", status)
	}

	p.OnDone = func(s restic.Stat, d time.Duration, ticker bool) {
		fmt.Printf("\n")
	}

	return p
}
Beispiel #6
0
func (t *Table) String() string {
	if t.Headers == nil && len(t.rows) < 1 {
		return ""
	}
	var ttyWidth int
	terminalFd := int(os.Stdout.Fd())
	if os.Getenv("TSURU_FORCE_WRAP") != "" {
		terminalFd = int(os.Stdin.Fd())
	}
	if terminal.IsTerminal(terminalFd) {
		ttyWidth, _, _ = terminal.GetSize(terminalFd)
	}
	sizes := t.resizeLastColumn(ttyWidth)
	result := t.separator()
	if t.Headers != nil {
		for column, header := range t.Headers {
			result += "| " + header
			result += strings.Repeat(" ", sizes[column]+1-len(header))
		}
		result += "|\n"
		result += t.separator()
	}
	result = t.addRows(t.rows, sizes, result)
	if !t.LineSeparator {
		result += t.separator()
	}
	return result
}
Beispiel #7
0
func newReadProgress(gopts GlobalOptions, todo restic.Stat) *restic.Progress {
	if gopts.Quiet {
		return nil
	}

	readProgress := restic.NewProgress()

	readProgress.OnUpdate = func(s restic.Stat, d time.Duration, ticker bool) {
		status := fmt.Sprintf("[%s] %s  %d / %d items",
			formatDuration(d),
			formatPercent(s.Blobs, todo.Blobs),
			s.Blobs, todo.Blobs)

		w, _, err := terminal.GetSize(int(os.Stdout.Fd()))
		if err == nil {
			if len(status) > w {
				max := w - len(status) - 4
				status = status[:max] + "... "
			}
		}

		PrintProgress("%s", status)
	}

	readProgress.OnDone = func(s restic.Stat, d time.Duration, ticker bool) {
		fmt.Printf("\nduration: %s\n", formatDuration(d))
	}

	return readProgress
}
Beispiel #8
0
func sendTermSize(control *websocket.Conn) error {
	width, height, err := terminal.GetSize(int(syscall.Stdout))
	if err != nil {
		return err
	}

	shared.Debugf("Window size is now: %dx%d", width, height)

	w, err := control.NextWriter(websocket.TextMessage)
	if err != nil {
		return err
	}

	msg := shared.ContainerExecControl{}
	msg.Command = "window-resize"
	msg.Args = make(map[string]string)
	msg.Args["width"] = strconv.Itoa(width)
	msg.Args["height"] = strconv.Itoa(height)

	buf, err := json.Marshal(msg)
	if err != nil {
		return err
	}
	_, err = w.Write(buf)

	w.Close()
	return err
}
Beispiel #9
0
func updateTerminalSize(term *terminal.Terminal) {
	width, height, err := terminal.GetSize(0)
	if err != nil {
		return
	}
	term.SetSize(width, height)
}
Beispiel #10
0
func GetSize() (int, int, error) {
	w, h, err := terminal.GetSize(int(os.Stdout.Fd()))
	if err != nil {
		return -1, -1, err
	}
	return w, h, nil
}
Beispiel #11
0
func (client NativeClient) OutputWithPty(command string) (string, error) {
	session, err := client.session(command)
	if err != nil {
		return "", nil
	}

	fd := int(os.Stdin.Fd())

	termWidth, termHeight, err := terminal.GetSize(fd)
	if err != nil {
		return "", err
	}

	modes := ssh.TerminalModes{
		ssh.ECHO:          0,
		ssh.TTY_OP_ISPEED: 14400,
		ssh.TTY_OP_OSPEED: 14400,
	}

	// request tty -- fixes error with hosts that use
	// "Defaults requiretty" in /etc/sudoers - I'm looking at you RedHat
	if err := session.RequestPty("xterm", termHeight, termWidth, modes); err != nil {
		return "", err
	}

	output, err := session.CombinedOutput(command)
	defer session.Close()

	return string(output), err
}
Beispiel #12
0
func connect(ip string, creds server.Credentials) error {
	config := &ssh.ClientConfig{
		User: creds.Username,
		Auth: []ssh.AuthMethod{
			ssh.Password(creds.Password),
		},
	}
	conn, err := ssh.Dial("tcp", fmt.Sprintf("%s:22", ip), config)
	if err != nil {
		return err
	}
	defer conn.Close()
	// Create a session
	session, err := conn.NewSession()
	defer session.Close()
	if err != nil {
		return err
	}

	fd := int(os.Stdin.Fd())
	oldState, err := terminal.MakeRaw(fd)
	if err != nil {
		return err
	}

	termWidth, termHeight, err := terminal.GetSize(fd)
	defer terminal.Restore(fd, oldState)
	if err != nil {
		return err
	}

	session.Stdout = os.Stdout
	session.Stderr = os.Stderr
	session.Stdin = os.Stdin

	modes := ssh.TerminalModes{
		ssh.ECHO:          1,     // disable echoing
		ssh.TTY_OP_ISPEED: 14400, // input speed = 14.4kbaud
		ssh.TTY_OP_OSPEED: 14400, // output speed = 14.4kbaud
	}
	// Request pseudo terminal
	if err := session.RequestPty("xterm-256color", termHeight, termWidth, modes); err != nil {
		return err
	}
	// Start remote shell
	if err := session.Shell(); err != nil {
		return err
	}

	if err := session.Wait(); err != nil {
		if reflect.TypeOf(err) == reflect.TypeOf(&ssh.ExitError{}) {
			return nil
		} else {
			return err
		}
	}

	return nil
}
Beispiel #13
0
func client(user, passwd, ip string) {
	config := &ssh.ClientConfig{
		User: user,
		Auth: []ssh.AuthMethod{
			ssh.Password(passwd),
		},
	}
	client, err := ssh.Dial("tcp", ip, config)
	if err != nil {
		fmt.Println("建立连接: ", err)
		return
	}
	defer client.Close()
	session, err := client.NewSession()
	if err != nil {
		fmt.Println("创建Session出错: ", err)
		return
	}
	defer session.Close()

	fd := int(os.Stdin.Fd())
	oldState, err := terminal.MakeRaw(fd)
	if err != nil {
		fmt.Println("创建文件描述符: ", err)
		return
	}

	session.Stdout = os.Stdout
	session.Stderr = os.Stderr
	session.Stdin = os.Stdin

	termWidth, termHeight, err := terminal.GetSize(fd)
	if err != nil {
		fmt.Println("获取窗口宽高: ", err)
		return
	}
	defer terminal.Restore(fd, oldState)

	modes := ssh.TerminalModes{
		ssh.ECHO:          1,
		ssh.TTY_OP_ISPEED: 14400,
		ssh.TTY_OP_OSPEED: 14400,
	}

	if err := session.RequestPty("xterm-256color", termHeight, termWidth, modes); err != nil {
		fmt.Println("创建终端出错: ", err)
		return
	}
	err = session.Shell()
	if err != nil {
		fmt.Println("执行Shell出错: ", err)
		return
	}
	err = session.Wait()
	if err != nil {
		fmt.Println("执行Wait出错: ", err)
		return
	}
}
Beispiel #14
0
func newArchiveProgress(gopts GlobalOptions, todo restic.Stat) *restic.Progress {
	if gopts.Quiet {
		return nil
	}

	archiveProgress := restic.NewProgress()

	var bps, eta uint64
	itemsTodo := todo.Files + todo.Dirs

	archiveProgress.OnUpdate = func(s restic.Stat, d time.Duration, ticker bool) {
		if IsProcessBackground() {
			return
		}

		sec := uint64(d / time.Second)
		if todo.Bytes > 0 && sec > 0 && ticker {
			bps = s.Bytes / sec
			if s.Bytes >= todo.Bytes {
				eta = 0
			} else if bps > 0 {
				eta = (todo.Bytes - s.Bytes) / bps
			}
		}

		itemsDone := s.Files + s.Dirs

		status1 := fmt.Sprintf("[%s] %s  %s/s  %s / %s  %d / %d items  %d errors  ",
			formatDuration(d),
			formatPercent(s.Bytes, todo.Bytes),
			formatBytes(bps),
			formatBytes(s.Bytes), formatBytes(todo.Bytes),
			itemsDone, itemsTodo,
			s.Errors)
		status2 := fmt.Sprintf("ETA %s ", formatSeconds(eta))

		w, _, err := terminal.GetSize(int(os.Stdout.Fd()))
		if err == nil {
			maxlen := w - len(status2) - 1

			if maxlen < 4 {
				status1 = ""
			} else if len(status1) > maxlen {
				status1 = status1[:maxlen-4]
				status1 += "... "
			}
		}

		PrintProgress("%s%s", status1, status2)
	}

	archiveProgress.OnDone = func(s restic.Stat, d time.Duration, ticker bool) {
		fmt.Printf("\nduration: %s, %s\n", formatDuration(d), formatRate(todo.Bytes, d))
	}

	return archiveProgress
}
Beispiel #15
0
func (r *LightRenderer) updateTerminalSize() {
	width, height, err := terminal.GetSize(r.fd())
	if err == nil {
		r.width = width
		r.height = r.maxHeightFunc(height)
	} else {
		r.width = getEnv("COLUMNS", defaultWidth)
		r.height = r.maxHeightFunc(getEnv("LINES", defaultHeight))
	}
}
Beispiel #16
0
// ClearLine creates a platform dependent string to clear the current
// line, so it can be overwritten. ANSI sequences are not supported on
// current windows cmd shell.
func ClearLine() string {
	if runtime.GOOS == "windows" {
		w, _, err := terminal.GetSize(int(os.Stdout.Fd()))
		if err == nil {
			return strings.Repeat(" ", w-1) + "\r"
		}
		return ""
	}
	return "\x1b[2K"
}
Beispiel #17
0
func displayJSONMessagesStream(in io.Reader, out io.Writer) (string, error) {
	var (
		dec        = json.NewDecoder(in)
		ids        = map[string]int{}
		diff       = 0
		fd         = getFd(out)
		isTerminal = terminal.IsTerminal(fd)
		message    = ""
	)

	//oldState, err := terminal.MakeRaw(fd)
	//if err == nil {
	//	defer terminal.Restore(fd, oldState)
	//}
	terminalWidth, terminalHeight, _ = terminal.GetSize(fd)

	for {
		var jm JSONMessage
		if err := dec.Decode(&jm); err != nil {
			if err == io.EOF {
				break
			}
			return "", err
		}

		if jm.ID != "" && (jm.Progress != nil || jm.ProgressMessage != "") {
			line, ok := ids[jm.ID]
			if !ok {
				line = len(ids)
				ids[jm.ID] = line
				if isTerminal {
					fmt.Fprintf(out, "\n")
				}
				diff = 0
			} else {
				diff = len(ids) - line
			}
			if jm.ID != "" && isTerminal {
				// <ESC>[{diff}A = move cursor up diff rows
				fmt.Fprintf(out, "%c[%dA", 27, diff)
			}
		}
		var err error
		message, err = jm.Display(out, isTerminal)
		if jm.ID != "" && isTerminal {
			// <ESC>[{diff}B = move cursor down diff rows
			fmt.Fprintf(out, "%c[%dB", 27, diff)
		}
		if err != nil {
			return "", err
		}
	}
	return message, nil
}
Beispiel #18
0
func (c *Common) height() int {
	if c.Height > 0 {
		return c.Height
	}
	if c.Height < 0 {
		// use screen height - y
		if _, h, err := terminal.GetSize(int(os.Stdin.Fd())); err == nil {
			return h + c.Height
		}
	}
	return DEFAULT_HEIGHT
}
Beispiel #19
0
func NewTextBuffer() *TextBuffer {
	w, h, err := terminal.GetSize(int(os.Stdout.Fd()))
	if err != nil {
		panic(err)
	}
	stdErr.Printf("Dimensions: (%d, %d)", w, h)
	return &TextBuffer{
		cursor: &Cursor{},
		width:  w,
		height: h,
	}
}
Beispiel #20
0
func (c *Common) width() int {
	if c.Width > 0 {
		return c.Width
	}
	if c.Width < 0 {
		// use screen width - x
		if w, _, err := terminal.GetSize(int(os.Stdin.Fd())); err == nil {
			return w + c.Width
		}
	}
	return DEFAULT_WIDTH
}
Beispiel #21
0
func PrintStory(story stories.Story) {
	cols, _, err := terminal.GetSize(0)
	if err != nil {
		cols = 128
	}
	cols -= 3

	fmt.Print("NAME: ")
	fmt.Print(story.Name)
	fmt.Println()

	fmt.Print("STATE: ")
	fmt.Print(story.State)
	fmt.Println()

	fmt.Print("OWNER: ")
	fmt.Print(story.Owner.Initials)
	fmt.Println()

	fmt.Println("DESCRIPTION:")
	fmt.Println(story.Description)
	fmt.Println()

	fmt.Print("TYPE: ")
	fmt.Print(story.StoryType)
	fmt.Println()

	fmt.Print("ESTIMATE: ")
	fmt.Print(story.Points)
	fmt.Println()

	fmt.Println("COMMENTS:")
	for _, comment := range story.Comments {
		createdTime, timeErr := time.Parse(time.RFC3339, comment.CreatedAt)
		if timeErr == nil {
			fmt.Println(createdTime.Local().String())
		} else {
			fmt.Println(comment.CreatedAt)
		}
		//fmt.Printf("\t%v\n", strings.Replace(comment.Text[0:int(math.Min(cols-8, float64(len(comment.Text))))], "\n", "\n\t", -1))
		fmt.Printf("> %v\n", strings.Replace(comment.Text, "\n", "\n>> ", -1))
		fmt.Println()
	}

	fmt.Print("LABELS: ")
	labelNames := []string{}
	for _, label := range story.Labels {
		labelNames = append(labelNames, label.Name)
	}
	fmt.Println(strings.Join(labelNames, ","))
	fmt.Println()
}
Beispiel #22
0
func (m *MinTerm) open() error {
	f, err := os.OpenFile("/dev/tty", os.O_RDWR, 0)
	if err != nil {
		return err
	}
	m.out = f
	fd := int(m.out.Fd())
	w, h, err := terminal.GetSize(fd)
	if err != nil {
		return err
	}
	m.width, m.height = w, h
	return nil
}
Beispiel #23
0
// GetTTYWidth returns the width of controlling TTY if it can or 80.
func GetTTYWidth() int {
	var tty *os.File
	var err error
	if tty, err = os.OpenFile("/dev/tty", os.O_RDWR, 0600); err != nil {
		tty = os.Stdout
	} else {
		defer tty.Close()
	}
	if width, _, err := terminal.GetSize(int(tty.Fd())); err != nil {
		return 80
	} else {
		return width - 1
	}
}
Beispiel #24
0
// printSummary prints a diff of charts after upate
func printSummary(diff string) {
	if len(diff) == 0 {
		log.Msg("Already up-to-date.")
		return
	}

	s := make(repoSummary)

	// parse git diff-tree
	for _, line := range strings.Split(diff, "\n") {
		kv := strings.Split(line, "\t")
		st, chart := kv[0], kv[1]

		s.add(st, chart)
	}

	// width of columns
	colwidth := 29

	// get console width
	maxwidth := 118
	if w, _, err := terminal.GetSize(int(os.Stdout.Fd())); err == nil {
		maxwidth = w
	}

	// print results
	for st, charts := range s {
		switch st {
		case "A":
			log.Msg("Added %d charts", len(charts))
		case "D":
			log.Msg("Sent %d charts to the depths", len(charts))
		case "M":
			log.Msg("Updated %d charts", len(charts))
		}

		line := ""
		for _, ch := range charts {
			// if adding this column passes the max
			// print and reset to zero
			if len(line)+colwidth > maxwidth {
				log.Msg(line)
				line = ""
			}
			// append to line with padding
			line = fmt.Sprintf("%s%-29s", line, ch)
		}
		log.Msg(line)
	}
}
Beispiel #25
0
func (cmd CmdBackup) newArchiveProgress(todo restic.Stat) *restic.Progress {
	if !cmd.global.ShowProgress() {
		return nil
	}

	archiveProgress := restic.NewProgress(time.Second)

	var bps, eta uint64
	itemsTodo := todo.Files + todo.Dirs

	archiveProgress.OnUpdate = func(s restic.Stat, d time.Duration, ticker bool) {
		sec := uint64(d / time.Second)
		if todo.Bytes > 0 && sec > 0 && ticker {
			bps = s.Bytes / sec
			if s.Bytes >= todo.Bytes {
				eta = 0
			} else if bps > 0 {
				eta = (todo.Bytes - s.Bytes) / bps
			}
		}

		itemsDone := s.Files + s.Dirs

		status1 := fmt.Sprintf("[%s] %s  %s/s  %s / %s  %d / %d items  %d errors  ",
			formatDuration(d),
			formatPercent(s.Bytes, todo.Bytes),
			formatBytes(bps),
			formatBytes(s.Bytes), formatBytes(todo.Bytes),
			itemsDone, itemsTodo,
			s.Errors)
		status2 := fmt.Sprintf("ETA %s ", formatSeconds(eta))

		w, _, err := terminal.GetSize(int(os.Stdout.Fd()))
		if err == nil {
			if len(status1)+len(status2) > w {
				max := w - len(status2) - 4
				status1 = status1[:max] + "... "
			}
		}

		fmt.Printf("\x1b[2K%s%s\r", status1, status2)
	}

	archiveProgress.OnDone = func(s restic.Stat, d time.Duration, ticker bool) {
		fmt.Printf("\nduration: %s, %s\n", formatDuration(d), formatRate(todo.Bytes, d))
	}

	return archiveProgress
}
Beispiel #26
0
// makeSession initializes a gossh.Session connected to the invoking process's stdout/stderr/stdout.
// If the invoking session is a terminal, a TTY will be requested for the SSH session.
// It returns a gossh.Session, a finalizing function used to clean up after the session terminates,
// and any error encountered in setting up the session.
func makeSession(client *SSHForwardingClient) (session *gossh.Session, finalize func(), err error) {
	session, err = client.NewSession()
	if err != nil {
		return
	}
	if err = client.ForwardAgentAuthentication(session); err != nil {
		return
	}

	session.Stdout = os.Stdout
	session.Stderr = os.Stderr
	session.Stdin = os.Stdin

	modes := gossh.TerminalModes{
		gossh.ECHO:          1,     // enable echoing
		gossh.TTY_OP_ISPEED: 14400, // input speed = 14.4kbaud
		gossh.TTY_OP_OSPEED: 14400, // output speed = 14.4kbaud
	}

	fd := int(os.Stdin.Fd())
	if terminal.IsTerminal(fd) {

		var termWidth, termHeight int
		var oldState *terminal.State

		oldState, err = terminal.MakeRaw(fd)
		if err != nil {
			return
		}

		finalize = func() {
			session.Close()
			terminal.Restore(fd, oldState)
		}

		termWidth, termHeight, err = terminal.GetSize(fd)

		if err != nil {
			return
		}
		err = session.RequestPty("xterm-256color", termHeight, termWidth, modes)
	} else {
		finalize = func() {
			session.Close()
		}
	}

	return
}
Beispiel #27
0
// copypaste from oldmain
func list(projectID string, accessToken string, include stories.IncludeOptions, style printing.PrintStyle) {

	_, h, err := terminal.GetSize(0)
	usePager := (err == nil)
	if _, err := exec.LookPath("less"); err != nil {
		usePager = false
	}

	// fetch stories
	numberOfStories := 0
	resp, fetcherror := stories.Fetch(projectID, accessToken, include)

	if fetcherror == nil {
		storyList := stories.Process(resp)
		numberOfStories = len(storyList)
		statusMap := stories.CountStories(storyList)

		usePager = usePager && (numberOfStories+3) > (h-1)

		if usePager {
			//http://stackoverflow.com/questions/21738674/how-do-i-print-a-buffer-to-stdout-piped-through-a-pager
			cmd := exec.Command("less")
			// create a pipe (blocking)
			r, stdin := io.Pipe()
			// Set your i/o's
			cmd.Stdin = r
			cmd.Stdout = os.Stdout
			cmd.Stderr = os.Stderr

			c := make(chan struct{})
			go func() {
				defer close(c)
				cmd.Run()
			}()
			printing.PrintStories(stdin, storyList, style)
			printing.PrintStatusLine(stdin, style, statusMap)
			stdin.Close()
			<-c
		} else {
			printing.PrintStories(os.Stdout, storyList, style)
			printing.PrintStatusLine(os.Stdout, style, statusMap)
		}

	} else {
		fmt.Println(fetcherror)
		panic("fetch error?")
	}
}
Beispiel #28
0
func (m *MinTerm) open() error {
	f, err := os.OpenFile("/dev/tty", os.O_RDWR, 0)
	if err != nil {
		return err
	}
	m.termIn = f
	m.termOut = f
	m.closeTermOut = false // since it's repeated
	fd := int(f.Fd())
	w, h, err := terminal.GetSize(fd)
	if err != nil {
		return err
	}
	m.width, m.height = w, h
	return nil
}
Beispiel #29
0
func listTask(ctx *cli.Context) error {
	tasks := pClient.GetTasks()
	termWidth, _, _ := terminal.GetSize(int(os.Stdout.Fd()))
	verbose := ctx.Bool("verbose")
	if tasks.Err != nil {
		return fmt.Errorf("Error getting tasks:\n%v\n", tasks.Err)
	}

	w := tabwriter.NewWriter(os.Stdout, 0, 8, 1, '\t', 0)
	if tasks.Len() == 0 {
		fmt.Println("No task found. Have you created a task?")
		return nil
	}
	printFields(w, false, 0,
		"ID",
		"NAME",
		"STATE",
		"HIT",
		"MISS",
		"FAIL",
		"CREATED",
		"LAST FAILURE",
	)
	for _, task := range tasks.ScheduledTasks {
		//165 is the width of the error message from ID - LAST FAILURE inclusive.
		//If the header row wraps, then the error message will automatically wrap too
		if termWidth < 165 {
			verbose = true
		}
		printFields(w, false, 0,
			task.ID,
			fixSize(verbose, task.Name, 41),
			task.State,
			trunc(task.HitCount),
			trunc(task.MissCount),
			trunc(task.FailedCount),
			task.CreationTime().Format(unionParseFormat),
			/*153 is the width of the error message from ID up to LAST FAILURE*/
			fixSize(verbose, task.LastFailureMessage, termWidth-153),
		)
	}
	w.Flush()

	return nil
}
Beispiel #30
0
func newArchiveStdinProgress(gopts GlobalOptions) *restic.Progress {
	if gopts.Quiet {
		return nil
	}

	archiveProgress := restic.NewProgress()

	var bps uint64

	archiveProgress.OnUpdate = func(s restic.Stat, d time.Duration, ticker bool) {
		if IsProcessBackground() {
			return
		}

		sec := uint64(d / time.Second)
		if s.Bytes > 0 && sec > 0 && ticker {
			bps = s.Bytes / sec
		}

		status1 := fmt.Sprintf("[%s] %s  %s/s", formatDuration(d),
			formatBytes(s.Bytes),
			formatBytes(bps))

		w, _, err := terminal.GetSize(int(os.Stdout.Fd()))
		if err == nil {
			maxlen := w - len(status1)

			if maxlen < 4 {
				status1 = ""
			} else if len(status1) > maxlen {
				status1 = status1[:maxlen-4]
				status1 += "... "
			}
		}

		PrintProgress("%s", status1)
	}

	archiveProgress.OnDone = func(s restic.Stat, d time.Duration, ticker bool) {
		fmt.Printf("\nduration: %s, %s\n", formatDuration(d), formatRate(s.Bytes, d))
	}

	return archiveProgress
}