container.go

/*
Copyright © 2020 The PES Open Source Team pesos@pes.edu

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package container

import (
	"context"
	"encoding/json"
	"fmt"
	"strings"
	"time"

	"github.com/docker/docker/api/types"
	"github.com/docker/docker/api/types/filters"
	"github.com/docker/docker/client"
	ui "github.com/gizak/termui/v3"
	"github.com/vyattalee/grofer/pkg/core"
)

// PerContainerMetrics holds metrics for a given container
type PerContainerMetrics struct {
	// Metrics common for Overall and per container
	ID     string
	Image  string
	Name   string
	Status string
	State  string
	CPU    float64
	Mem    float64
	Net    netStat
	Blk    blkStat
	// Metrics specific to per container
	Pid     string
	NetInfo []netInfo
	PerCPU  []string
	PortMap []portMap
	Mounts  []mountInfo
	Procs   []procInfo
}

type netStat struct {
	Rx float64
	Tx float64
}

type blkStat struct {
	Read  uint64
	Write uint64
}

type netInfo struct {
	Name    string
	Driver  string
	IP      string
	Ingress bool
}

type mountInfo struct {
	Src  string
	Dst  string
	Mode string
}

type portMap struct {
	IP        string
	Host      int
	Container int
	Protocol  string
}

type procInfo struct {
	UID string
	PID string
	CMD string
}

func getCPUPercent(data *types.StatsJSON) float64 {
	cpuPercent := 0.0
	numCPUs := len(data.CPUStats.CPUUsage.PercpuUsage)

	cpuDelta := float64(data.CPUStats.CPUUsage.TotalUsage) - float64(data.PreCPUStats.CPUUsage.TotalUsage)

	systemDelta := float64(data.CPUStats.SystemUsage) - float64(data.PreCPUStats.SystemUsage)

	if cpuDelta > 0.0 && systemDelta > 0.0 {
		cpuPercent = (cpuDelta / systemDelta) * float64(numCPUs) * 100.0
	}
	return cpuPercent
}

func getPerCPUPercents(data *types.StatsJSON) []string {
	preLen := len(data.PreCPUStats.CPUUsage.PercpuUsage)
	postLen := len(data.CPUStats.CPUUsage.PercpuUsage)
	numCPUs := ui.MaxInt(preLen, postLen)

	perCPUPercents := make([]string, numCPUs)
	systemDelta := float64(data.CPUStats.SystemUsage) - float64(data.PreCPUStats.SystemUsage)

	// If first run, skip percpu metrics
	if preLen != postLen {
		for i := range perCPUPercents {
			perCPUPercents[i] = "NA"
		}
	} else {
		for i, usage := range data.CPUStats.CPUUsage.PercpuUsage {
			perCPUPercent := 0.0

			cpuDelta := float64(usage) - float64(data.PreCPUStats.CPUUsage.PercpuUsage[i])

			if cpuDelta > 0.0 && systemDelta > 0.0 {
				perCPUPercent = (cpuDelta / systemDelta) * float64(numCPUs) * 100.0
			}
			perCPUPercents[i] = fmt.Sprintf("%.2f%%", perCPUPercent)
		}
	}
	return perCPUPercents
}

// Wait waits for a container of given container id to reach a specified state.
// If an error is encountered during the wait, it is returned.
func Wait(ctx context.Context, cli *client.Client, cid, state string) error {

	t := time.NewTicker(100 * time.Millisecond)
	tick := t.C

	timeout := time.NewTimer(1 * time.Minute)
	timeoutChan := timeout.C

	for {
		select {
		case <-timeoutChan:
			return fmt.Errorf("failed to reach state '%s' for container %s", state, cid)

		case <-tick:
			data, err := cli.ContainerInspect(ctx, cid)
			if err != nil {
				return err
			}
			if data.State.Status == state {
				return nil
			}
		}
	}
}

// GetContainerMetrics provides per container metrics in the form of PerContainerMetrics Structs.
func GetContainerMetrics(ctx context.Context, cli *client.Client, cid string) (PerContainerMetrics, error) {
	metrics := PerContainerMetrics{}

	// Get container using a filter
	args := filters.NewArgs(
		filters.KeyValuePair{
			Key:   "id",
			Value: cid,
		},
	)

	containers, err := cli.ContainerList(ctx, types.ContainerListOptions{Filters: args})
	if err != nil {
		return metrics, err
	}

	if len(containers) > 1 {
		return metrics, fmt.Errorf("multiple containers with same ID exist")
	} else if len(containers) < 1 {
		return metrics, core.ErrInvalidContainer
	}

	c := containers[0]

	// Get PID
	inspectData, err := cli.ContainerInspect(ctx, cid)
	if err != nil {
		return metrics, nil
	}

	// Get Container Stats
	stats, err := cli.ContainerStats(ctx, cid, false)
	if err != nil {
		return metrics, err
	}

	data := types.StatsJSON{}
	err = json.NewDecoder(stats.Body).Decode(&data)
	if err != nil {
		return metrics, err
	}
	stats.Body.Close()

	// Calculate CPU percent
	cpuPercent := getCPUPercent(&data)

	// Get Per CPU utilizations
	perCPUPercents := getPerCPUPercents(&data)

	// Calculate Memory usage
	memPercent := float64(data.MemoryStats.Usage) / float64(data.MemoryStats.Limit) * 100

	// Calculate Network Metrics
	var rx, tx float64
	for _, v := range data.Networks {
		rx += float64(v.RxBytes)
		tx += float64(v.TxBytes)
	}

	// Calculate blk IO
	var blkRead, blkWrite uint64
	for _, bioEntry := range data.BlkioStats.IoServiceBytesRecursive {
		switch strings.ToLower(bioEntry.Op) {
		case "read":
			blkRead = blkRead + bioEntry.Value
		case "write":
			blkWrite = blkWrite + bioEntry.Value
		}
	}

	// Get Network Settings
	netData := []netInfo{}
	for _, network := range c.NetworkSettings.Networks {
		id := network.NetworkID

		net, err := cli.NetworkInspect(ctx, id, types.NetworkInspectOptions{})
		if err != nil {
			continue
		}

		n := netInfo{
			Name:    net.Name,
			Driver:  net.Driver,
			IP:      network.IPAddress,
			Ingress: net.Ingress,
		}

		netData = append(netData, n)
	}

	// Get Port mappings
	portData := []portMap{}
	for _, port := range c.Ports {
		p := portMap{
			IP:        port.IP,
			Host:      int(port.PublicPort),
			Container: int(port.PrivatePort),
			Protocol:  port.Type,
		}

		portData = append(portData, p)
	}

	// Get mounted volumes
	mountData := []mountInfo{}
	for _, mount := range c.Mounts {
		m := mountInfo{
			Src:  mount.Source,
			Dst:  mount.Destination,
			Mode: mount.Mode,
		}

		mountData = append(mountData, m)
	}

	// Get processes in container
	procs, err := cli.ContainerTop(ctx, cid, []string{})
	if err != nil {
		return metrics, nil
	}

	procData := []procInfo{}
	for _, proc := range procs.Processes {
		p := procInfo{
			UID: proc[0],
			PID: proc[1],
			CMD: proc[7],
		}

		procData = append(procData, p)
	}

	// Populate metrics
	metrics = PerContainerMetrics{
		ID:      c.ID[:10],
		Image:   c.Image,
		Name:    strings.TrimLeft(strings.Join(c.Names, ","), "/"),
		Status:  c.Status,
		State:   c.State,
		CPU:     cpuPercent,
		Mem:     memPercent,
		Net:     netStat{Rx: rx, Tx: tx},
		Blk:     blkStat{Read: blkRead, Write: blkWrite},
		Pid:     fmt.Sprintf("%d", inspectData.State.Pid),
		NetInfo: netData,
		PerCPU:  perCPUPercents,
		PortMap: portData,
		Mounts:  mountData,
		Procs:   procData,
	}

	return metrics, nil
}