Tests are working again

scheduler/task/check_ports.go

@@ -0,0 +1,55 @@
+package task
+
+import (
+	"context"
+	"log"
+
+	"github.com/play-with-docker/play-with-docker/docker"
+	"github.com/play-with-docker/play-with-docker/event"
+	"github.com/play-with-docker/play-with-docker/pwd/types"
+)
+
+type DockerPorts struct {
+	Instance string `json:"instance"`
+	Ports    []int  `json:"ports"`
+}
+
+type checkPorts struct {
+	event   event.EventApi
+	factory docker.FactoryApi
+}
+
+var CheckPortsEvent event.EventType
+
+func init() {
+	CheckPortsEvent = event.NewEventType("instance docker ports")
+}
+
+func (t *checkPorts) Name() string {
+	return "CheckPorts"
+}
+
+func (t *checkPorts) Run(ctx context.Context, instance *types.Instance) error {
+	dockerClient, err := t.factory.GetForInstance(instance.SessionId, instance.Name)
+	if err != nil {
+		log.Println(err)
+		return err
+	}
+
+	ps, err := dockerClient.GetPorts()
+	if err != nil {
+		log.Println(err)
+		return err
+	}
+	ports := make([]int, len(ps))
+	for i, port := range ps {
+		ports[i] = int(port)
+	}
+
+	t.event.Emit(CheckPortsEvent, instance.SessionId, DockerPorts{Instance: instance.Name, Ports: ports})
+	return nil
+}
+
+func NewCheckPorts(e event.EventApi, f docker.FactoryApi) *checkPorts {
+	return &checkPorts{event: e, factory: f}
+}

scheduler/task/check_ports_test.go

@@ -0,0 +1,48 @@
+package task
+
+import (
+	"context"
+	"testing"
+
+	"github.com/play-with-docker/play-with-docker/docker"
+	"github.com/play-with-docker/play-with-docker/event"
+	"github.com/play-with-docker/play-with-docker/pwd/types"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCheckPorts_Name(t *testing.T) {
+	e := &event.Mock{}
+	f := &docker.FactoryMock{}
+
+	task := NewCheckPorts(e, f)
+
+	assert.Equal(t, "CheckPorts", task.Name())
+	e.M.AssertExpectations(t)
+	f.AssertExpectations(t)
+}
+
+func TestCheckPorts_Run(t *testing.T) {
+	d := &docker.Mock{}
+	e := &event.Mock{}
+	f := &docker.FactoryMock{}
+
+	d.On("GetPorts").Return([]uint16{8080, 9090}, nil)
+	f.On("GetForInstance", "aaaabbbbcccc", "aaaabbbb_node1").Return(d, nil)
+	e.M.On("Emit", CheckPortsEvent, "aaaabbbbcccc", []interface{}{DockerPorts{Instance: "aaaabbbb_node1", Ports: []int{8080, 9090}}}).Return()
+
+	i := &types.Instance{
+		IP:        "10.0.0.1",
+		Name:      "aaaabbbb_node1",
+		SessionId: "aaaabbbbcccc",
+	}
+
+	task := NewCheckPorts(e, f)
+	ctx := context.Background()
+
+	err := task.Run(ctx, i)
+
+	assert.Nil(t, err)
+	d.AssertExpectations(t)
+	e.M.AssertExpectations(t)
+	f.AssertExpectations(t)
+}

scheduler/task/check_swarm_ports.go

@@ -0,0 +1,72 @@
+package task
+
+import (
+	"context"
+	"fmt"
+	"log"
+
+	"github.com/play-with-docker/play-with-docker/docker"
+	"github.com/play-with-docker/play-with-docker/event"
+	"github.com/play-with-docker/play-with-docker/pwd/types"
+)
+
+type DockerSwarmPorts struct {
+	Manager   string   `json:"manager"`
+	Instances []string `json:"instances"`
+	Ports     []int    `json:"ports"`
+}
+
+type checkSwarmPorts struct {
+	event   event.EventApi
+	factory docker.FactoryApi
+}
+
+var CheckSwarmPortsEvent event.EventType
+
+func init() {
+	CheckSwarmPortsEvent = event.NewEventType("instance docker swarm ports")
+}
+
+func (t *checkSwarmPorts) Name() string {
+	return "CheckSwarmPorts"
+}
+
+func (t *checkSwarmPorts) Run(ctx context.Context, instance *types.Instance) error {
+	dockerClient, err := t.factory.GetForInstance(instance.SessionId, instance.Name)
+	if err != nil {
+		log.Println(err)
+		return err
+	}
+
+	status, err := getDockerSwarmStatus(ctx, dockerClient)
+	if err != nil {
+		log.Println(err)
+		return err
+	}
+
+	if !status.IsManager {
+		return nil
+	}
+
+	hosts, ps, err := dockerClient.GetSwarmPorts()
+	if err != nil {
+		log.Println(err)
+		return err
+	}
+	instances := make([]string, len(hosts))
+	sessionPrefix := instance.SessionId[:8]
+	for i, host := range hosts {
+		instances[i] = fmt.Sprintf("%s_%s", sessionPrefix, host)
+	}
+	ports := make([]int, len(ps))
+	for i, port := range ps {
+		ports[i] = int(port)
+	}
+
+	t.event.Emit(CheckSwarmPortsEvent, instance.SessionId, DockerSwarmPorts{Manager: instance.Name, Instances: instances, Ports: ports})
+	return nil
+}
+
+func NewCheckSwarmPorts(e event.EventApi, f docker.FactoryApi) *checkSwarmPorts {
+	return &checkSwarmPorts{event: e, factory: f}
+}

scheduler/task/check_swarm_ports_test.go

@@ -0,0 +1,57 @@
+package task
+
+import (
+	"context"
+	"testing"
+
+	dockerTypes "github.com/docker/docker/api/types"
+	"github.com/docker/docker/api/types/swarm"
+	"github.com/play-with-docker/play-with-docker/docker"
+	"github.com/play-with-docker/play-with-docker/event"
+	"github.com/play-with-docker/play-with-docker/pwd/types"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCheckSwarmPorts_Name(t *testing.T) {
+	e := &event.Mock{}
+	f := &docker.FactoryMock{}
+
+	task := NewCheckSwarmPorts(e, f)
+
+	assert.Equal(t, "CheckSwarmPorts", task.Name())
+	e.M.AssertExpectations(t)
+	f.AssertExpectations(t)
+}
+
+func TestCheckSwarmPorts_RunWhenManager(t *testing.T) {
+	d := &docker.Mock{}
+	e := &event.Mock{}
+	f := &docker.FactoryMock{}
+
+	i := &types.Instance{
+		IP:        "10.0.0.1",
+		Name:      "aaaabbbb_node1",
+		SessionId: "aaaabbbbcccc",
+	}
+	info := dockerTypes.Info{
+		Swarm: swarm.Info{
+			LocalNodeState:   swarm.LocalNodeStateActive,
+			ControlAvailable: true,
+		},
+	}
+
+	f.On("GetForInstance", "aaaabbbbcccc", "aaaabbbb_node1").Return(d, nil)
+	d.On("GetDaemonInfo").Return(info, nil)
+	d.On("GetSwarmPorts").Return([]string{"node1", "node2"}, []uint16{8080, 9090}, nil)
+	e.M.On("Emit", CheckSwarmPortsEvent, "aaaabbbbcccc", []interface{}{DockerSwarmPorts{Manager: i.Name, Instances: []string{i.Name, "aaaabbbb_node2"}, Ports: []int{8080, 9090}}}).Return()
+
+	task := NewCheckSwarmPorts(e, f)
+	ctx := context.Background()
+
+	err := task.Run(ctx, i)
+
+	assert.Nil(t, err)
+	d.AssertExpectations(t)
+	e.M.AssertExpectations(t)
+	f.AssertExpectations(t)
+}

scheduler/task/check_swarm_status.go

@@ -0,0 +1,69 @@
+package task
+
+import (
+	"context"
+	"log"
+
+	"github.com/docker/docker/api/types/swarm"
+	"github.com/play-with-docker/play-with-docker/docker"
+	"github.com/play-with-docker/play-with-docker/event"
+	"github.com/play-with-docker/play-with-docker/pwd/types"
+)
+
+type DockerSwarmStatus struct {
+	IsManager bool   `json:"is_manager"`
+	IsWorker  bool   `json:"is_worker"`
+	Instance  string `json:"instance"`
+}
+
+type checkSwarmStatus struct {
+	event   event.EventApi
+	factory docker.FactoryApi
+}
+
+var CheckSwarmStatusEvent event.EventType
+
+func init() {
+	CheckSwarmStatusEvent = event.NewEventType("instance docker swarm status")
+}
+
+func (t *checkSwarmStatus) Name() string {
+	return "CheckSwarmStatus"
+}
+
+func (t *checkSwarmStatus) Run(ctx context.Context, instance *types.Instance) error {
+	dockerClient, err := t.factory.GetForInstance(instance.SessionId, instance.Name)
+	if err != nil {
+		log.Println(err)
+		return err
+	}
+
+	status, err := getDockerSwarmStatus(ctx, dockerClient)
+	if err != nil {
+		log.Println(err)
+		return err
+	}
+	status.Instance = instance.Name
+
+	t.event.Emit(CheckSwarmStatusEvent, instance.SessionId, status)
+	return nil
+}
+
+func NewCheckSwarmStatus(e event.EventApi, f docker.FactoryApi) *checkSwarmStatus {
+	return &checkSwarmStatus{event: e, factory: f}
+}
+
+func getDockerSwarmStatus(ctx context.Context, client docker.DockerApi) (DockerSwarmStatus, error) {
+	status := DockerSwarmStatus{}
+	info, err := client.GetDaemonInfo()
+	if err != nil {
+		return status, err
+	}
+
+	if info.Swarm.LocalNodeState != swarm.LocalNodeStateInactive && info.Swarm.LocalNodeState != swarm.LocalNodeStateLocked {
+		status.IsManager = info.Swarm.ControlAvailable
+		status.IsWorker = !info.Swarm.ControlAvailable
+	}
+
+	return status, nil
+}

scheduler/task/check_swarm_status_test.go

@@ -0,0 +1,150 @@
+package task
+
+import (
+	"context"
+	"testing"
+
+	dockerTypes "github.com/docker/docker/api/types"
+	"github.com/docker/docker/api/types/swarm"
+	"github.com/play-with-docker/play-with-docker/docker"
+	"github.com/play-with-docker/play-with-docker/event"
+	"github.com/play-with-docker/play-with-docker/pwd/types"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCheckSwarmStatus_Name(t *testing.T) {
+	e := &event.Mock{}
+	f := &docker.FactoryMock{}
+
+	task := NewCheckSwarmStatus(e, f)
+
+	assert.Equal(t, "CheckSwarmStatus", task.Name())
+	e.M.AssertExpectations(t)
+	f.AssertExpectations(t)
+}
+
+func TestCheckSwarmStatus_RunWhenInactive(t *testing.T) {
+	d := &docker.Mock{}
+	e := &event.Mock{}
+	f := &docker.FactoryMock{}
+
+	i := &types.Instance{
+		IP:        "10.0.0.1",
+		Name:      "node1",
+		SessionId: "aaabbbccc",
+	}
+	infoInactive := dockerTypes.Info{
+		Swarm: swarm.Info{
+			LocalNodeState: swarm.LocalNodeStateInactive,
+		},
+	}
+
+	f.On("GetForInstance", "aaabbbccc", "node1").Return(d, nil)
+	d.On("GetDaemonInfo").Return(infoInactive, nil)
+	e.M.On("Emit", CheckSwarmStatusEvent, "aaabbbccc", []interface{}{DockerSwarmStatus{IsManager: false, IsWorker: false, Instance: "node1"}}).Return()
+
+	task := NewCheckSwarmStatus(e, f)
+	ctx := context.Background()
+
+	err := task.Run(ctx, i)
+
+	assert.Nil(t, err)
+	d.AssertExpectations(t)
+	e.M.AssertExpectations(t)
+	f.AssertExpectations(t)
+}
+
+func TestCheckSwarmStatus_RunWhenLocked(t *testing.T) {
+	d := &docker.Mock{}
+	e := &event.Mock{}
+	f := &docker.FactoryMock{}
+
+	i := &types.Instance{
+		IP:        "10.0.0.1",
+		Name:      "node1",
+		SessionId: "aaabbbccc",
+	}
+	infoLocked := dockerTypes.Info{
+		Swarm: swarm.Info{
+			LocalNodeState: swarm.LocalNodeStateLocked,
+		},
+	}
+
+	f.On("GetForInstance", "aaabbbccc", "node1").Return(d, nil)
+	d.On("GetDaemonInfo").Return(infoLocked, nil)
+	e.M.On("Emit", CheckSwarmStatusEvent, "aaabbbccc", []interface{}{DockerSwarmStatus{IsManager: false, IsWorker: false, Instance: "node1"}}).Return()
+
+	task := NewCheckSwarmStatus(e, f)
+	ctx := context.Background()
+
+	err := task.Run(ctx, i)
+
+	assert.Nil(t, err)
+	d.AssertExpectations(t)
+	e.M.AssertExpectations(t)
+	f.AssertExpectations(t)
+}
+
+func TestCheckSwarmStatus_RunWhenManager(t *testing.T) {
+	d := &docker.Mock{}
+	e := &event.Mock{}
+	f := &docker.FactoryMock{}
+
+	i := &types.Instance{
+		IP:        "10.0.0.1",
+		Name:      "node1",
+		SessionId: "aaabbbccc",
+	}
+	infoLocked := dockerTypes.Info{
+		Swarm: swarm.Info{
+			LocalNodeState:   swarm.LocalNodeStateActive,
+			ControlAvailable: true,
+		},
+	}
+
+	f.On("GetForInstance", "aaabbbccc", "node1").Return(d, nil)
+	d.On("GetDaemonInfo").Return(infoLocked, nil)
+	e.M.On("Emit", CheckSwarmStatusEvent, "aaabbbccc", []interface{}{DockerSwarmStatus{IsManager: true, IsWorker: false, Instance: "node1"}}).Return()
+
+	task := NewCheckSwarmStatus(e, f)
+	ctx := context.Background()
+
+	err := task.Run(ctx, i)
+
+	assert.Nil(t, err)
+	d.AssertExpectations(t)
+	e.M.AssertExpectations(t)
+	f.AssertExpectations(t)
+}
+
+func TestCheckSwarmStatus_RunWhenWorker(t *testing.T) {
+	d := &docker.Mock{}
+	e := &event.Mock{}
+	f := &docker.FactoryMock{}
+
+	i := &types.Instance{
+		IP:        "10.0.0.1",
+		Name:      "node1",
+		SessionId: "aaabbbccc",
+	}
+	infoLocked := dockerTypes.Info{
+		Swarm: swarm.Info{
+			LocalNodeState:   swarm.LocalNodeStateActive,
+			ControlAvailable: false,
+		},
+	}
+
+	f.On("GetForInstance", "aaabbbccc", "node1").Return(d, nil)
+	d.On("GetDaemonInfo").Return(infoLocked, nil)
+	e.M.On("Emit", CheckSwarmStatusEvent, "aaabbbccc", []interface{}{DockerSwarmStatus{IsManager: false, IsWorker: true, Instance: "node1"}}).Return()
+
+	task := NewCheckSwarmStatus(e, f)
+	ctx := context.Background()
+
+	err := task.Run(ctx, i)
+
+	assert.Nil(t, err)
+	d.AssertExpectations(t)
+	e.M.AssertExpectations(t)
+	f.AssertExpectations(t)
+}

scheduler/task/collect_stats.go

@@ -0,0 +1,93 @@
+package task
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log"
+
+	dockerTypes "github.com/docker/docker/api/types"
+	units "github.com/docker/go-units"
+	"github.com/play-with-docker/play-with-docker/docker"
+	"github.com/play-with-docker/play-with-docker/event"
+	"github.com/play-with-docker/play-with-docker/pwd/types"
+)
+
+type InstanceStats struct {
+	Instance string `json:"instance"`
+	Mem      string `json:"mem"`
+	Cpu      string `json:"cpu"`
+}
+
+type collectStats struct {
+	event   event.EventApi
+	factory docker.FactoryApi
+}
+
+var CollectStatsEvent event.EventType
+
+func init() {
+	CollectStatsEvent = event.NewEventType("instance stats")
+}
+
+func (t *collectStats) Name() string {
+	return "CollectStats"
+}
+
+func (t *collectStats) Run(ctx context.Context, instance *types.Instance) error {
+	dockerClient, err := t.factory.GetForSession(instance.SessionId)
+	if err != nil {
+		log.Println(err)
+		return err
+	}
+	reader, err := dockerClient.GetContainerStats(instance.Name)
+	if err != nil {
+		log.Println("Error while trying to collect instance stats", err)
+		return err
+	}
+	dec := json.NewDecoder(reader)
+	var v *dockerTypes.StatsJSON
+	e := dec.Decode(&v)
+	if e != nil {
+		log.Println("Error while trying to collect instance stats", e)
+		return err
+	}
+	stats := InstanceStats{Instance: instance.Name}
+	// Memory
+	var memPercent float64 = 0
+	if v.MemoryStats.Limit != 0 {
+		memPercent = float64(v.MemoryStats.Usage) / float64(v.MemoryStats.Limit) * 100.0
+	}
+	mem := float64(v.MemoryStats.Usage)
+	memLimit := float64(v.MemoryStats.Limit)
+
+	stats.Mem = fmt.Sprintf("%.2f%% (%s / %s)", memPercent, units.BytesSize(mem), units.BytesSize(memLimit))
+
+	// cpu
+	previousCPU := v.PreCPUStats.CPUUsage.TotalUsage
+	previousSystem := v.PreCPUStats.SystemUsage
+	cpuPercent := calculateCPUPercentUnix(previousCPU, previousSystem, v)
+	stats.Cpu = fmt.Sprintf("%.2f%%", cpuPercent)
+
+	t.event.Emit(CollectStatsEvent, instance.SessionId, stats)
+	return nil
+}
+
+func NewCollectStats(e event.EventApi, f docker.FactoryApi) *collectStats {
+	return &collectStats{event: e, factory: f}
+}
+
+func calculateCPUPercentUnix(previousCPU, previousSystem uint64, v *dockerTypes.StatsJSON) float64 {
+	var (
+		cpuPercent = 0.0
+		// calculate the change for the cpu usage of the container in between readings
+		cpuDelta = float64(v.CPUStats.CPUUsage.TotalUsage) - float64(previousCPU)
+		// calculate the change for the entire system between readings
+		systemDelta = float64(v.CPUStats.SystemUsage) - float64(previousSystem)
+	)
+
+	if systemDelta > 0.0 && cpuDelta > 0.0 {
+		cpuPercent = (cpuDelta / systemDelta) * float64(len(v.CPUStats.CPUUsage.PercpuUsage)) * 100.0
+	}
+	return cpuPercent
+}

scheduler/task/collect_stats_test.go

@@ -0,0 +1,71 @@
+package task
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"io"
+	"testing"
+
+	dockerTypes "github.com/docker/docker/api/types"
+	"github.com/play-with-docker/play-with-docker/docker"
+	"github.com/play-with-docker/play-with-docker/event"
+	"github.com/play-with-docker/play-with-docker/pwd/types"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+)
+
+type mockSessionProvider struct {
+	mock.Mock
+}
+
+func (m *mockSessionProvider) GetDocker(sessionId string) (docker.DockerApi, error) {
+	args := m.Called(sessionId)
+
+	return args.Get(0).(docker.DockerApi), args.Error(1)
+}
+
+type nopCloser struct {
+	io.Reader
+}
+
+func (nopCloser) Close() error { return nil }
+
+func TestCollectStats_Name(t *testing.T) {
+	e := &event.Mock{}
+	f := &docker.FactoryMock{}
+
+	task := NewCollectStats(e, f)
+
+	assert.Equal(t, "CollectStats", task.Name())
+	e.M.AssertExpectations(t)
+	f.AssertExpectations(t)
+}
+
+func TestCollectStats_Run(t *testing.T) {
+	d := &docker.Mock{}
+	e := &event.Mock{}
+	f := &docker.FactoryMock{}
+
+	stats := dockerTypes.StatsJSON{}
+	b, _ := json.Marshal(stats)
+	i := &types.Instance{
+		IP:        "10.0.0.1",
+		Name:      "aaaabbbb_node1",
+		SessionId: "aaaabbbbcccc",
+	}
+
+	f.On("GetForSession", i.SessionId).Return(d, nil)
+	d.On("GetContainerStats", i.Name).Return(nopCloser{bytes.NewReader(b)}, nil)
+	e.M.On("Emit", CollectStatsEvent, "aaaabbbbcccc", []interface{}{InstanceStats{Instance: i.Name, Mem: "0.00% (0B / 0B)", Cpu: "0.00%"}}).Return()
+
+	task := NewCollectStats(e, f)
+	ctx := context.Background()
+
+	err := task.Run(ctx, i)
+
+	assert.Nil(t, err)
+	d.AssertExpectations(t)
+	e.M.AssertExpectations(t)
+	f.AssertExpectations(t)
+}