Continue to develop SSH client

Author: Phantas0s

internal/monitor_server_widget.go

@@ -6,7 +6,7 @@ import (
 
 type monitorServerWidget struct {
 	tui    *Tui
-	client platform.SSH
+	client *platform.SSH
 }
 
 func NewMonitorServerWidget(username, addr string) (*monitorServerWidget, error) {
@@ -23,3 +23,13 @@ func NewMonitorServerWidget(username, addr string) (*monitorServerWidget, error)
 func (ms *monitorServerWidget) CreateWidgets(widget Widget, tui *Tui) (f func() error, err error) {
 	return nil, nil
 }
+
+func (ms *monitorServerWidget) GetMemory(widget Widget, tui *Tui) (f func() error, err error) {
+	// headers MemTotal, MemFree, Buffers, Cached, SwapTotal, SwapFree
+	return func() error {
+		return nil
+	}, nil
+}
+
+// func (ms *monitorServerWidget) table(widget Widget, firstHeader string) (f func() error, err error) {
+// }

internal/platform/ssh.go

@@ -1,8 +1,12 @@
 package platform
 
 import (
+	"bufio"
+	"bytes"
 	"net"
 	"os"
+	"strconv"
+	"strings"
 
 	"github.com/pkg/errors"
 	"golang.org/x/crypto/ssh"
@@ -18,12 +22,12 @@ type SSH struct {
 }
 
 // TODO accept more method of connection than only via ssh-agent
-func NewSSHClient(username, addr string) (SSH, error) {
+func NewSSHClient(username, addr string) (*SSH, error) {
 	sshClient, err := createAgentAuth(username, addr)
 	if err != nil {
-		return SSH{}, err
+		return nil, err
 	}
-	return SSH{
+	return &SSH{
 		client: sshClient,
 	}, nil
 }
@@ -48,3 +52,84 @@ func createAgentAuth(username, addr string) (*ssh.Client, error) {
 
 	return ssh.Dial("tcp", addr, config)
 }
+
+// Run a command on remote server via SSH
+func (s *SSH) Run(command string) (string, error) {
+	session, err := s.client.NewSession()
+	if err != nil {
+		return "", errors.Wrapf(err, "can't create session with SSH client for command %s", command)
+	}
+	defer session.Close()
+
+	var buf bytes.Buffer
+	session.Stdout = &buf
+	err = session.Run(command)
+	if err != nil {
+		return "", errors.Wrapf(err, "can't run command %s on remote server", command)
+	}
+
+	return string(buf.Bytes()), nil
+}
+
+func (s *SSH) getMemoryInfo(headers []string, metrics []string) (cells [][]string, err error) {
+	lines, err := s.Run("/bin/cat /proc/meminfo")
+	if err != nil {
+		return nil, err
+	}
+
+	scanner := bufio.NewScanner(strings.NewReader(lines))
+	var data string
+	for scanner.Scan() {
+		line := scanner.Text()
+		parts := strings.Fields(line)
+
+		if len(parts) == 3 {
+			val, err := strconv.ParseUint(parts[1], 10, 64)
+			val = incSizeMetric(val)
+			if err != nil {
+				data += "unknown" + ","
+				continue
+			}
+
+			for _, v := range metrics {
+				if parts[0] == v {
+					data += strconv.FormatInt(int64(val), 10) + ","
+				}
+			}
+		}
+	}
+
+	cells = append(cells, headers)
+	for _, v := range formatToTable(headers, data) {
+		cells = append(cells, v)
+	}
+
+	return cells, nil
+}
+
+// formatToTable display.
+// The string needs to have this:
+// Info needs to be splitted with comma
+// Depending on number of columns (headers)
+// TODO improve this comment :D
+func formatToTable(headers []string, data string) (cells [][]string) {
+	col := len(headers)
+	c := strings.Split(data, ",")
+	lenCells := len(c)
+	for i := 0; i < lenCells; i += col {
+		cells = append(cells, c[i:min(i+col, lenCells)])
+	}
+
+	return cells
+}
+
+func min(a, b int) int {
+	if a <= b {
+		return a
+	}
+	return b
+}
+
+func incSizeMetric(val uint64) uint64 {
+	return val / 1024
+}

internal/platform/ssh_test.go

@@ -0,0 +1,39 @@
+package platform
+
+import (
+	"reflect"
+	"testing"
+)
+
+func Test_formatToTable(t *testing.T) {
+	testCases := []struct {
+		name     string
+		expected [][]string
+		headers  []string
+		data     string
+	}{
+		{
+			name: "happy case",
+			expected: [][]string{
+				{
+					"data1", "data2", "data3", "data4",
+				},
+				{
+					"data5", "data6", "data7", "data8",
+				},
+			},
+			headers: []string{"dataHeader1", "dataHeader2", "dataHeader3", "dataHeader4"},
+			data:    "data1,data2,data3,data4,data5,data6,data7,data8",
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			actual := formatToTable(tc.headers, tc.data)
+
+			if !reflect.DeepEqual(actual, tc.expected) {
+				t.Errorf("Expected %v, actual %v", tc.expected, actual)
+			}
+		})
+	}
+}