165 lines
3.3 KiB
Go
165 lines
3.3 KiB
Go
package docker
|
|
|
|
import (
|
|
"log"
|
|
"path"
|
|
|
|
"github.com/rosti-cz/node-api/apps"
|
|
)
|
|
|
|
// Container extends App struct from App
|
|
type Container struct {
|
|
App *apps.App `json:"app"`
|
|
}
|
|
|
|
func (c *Container) getDriver() *Driver {
|
|
driver := &Driver{}
|
|
return driver
|
|
}
|
|
|
|
// volumeHostPath each container has one volume mounted into it,
|
|
func (c *Container) volumeHostPath() string {
|
|
return path.Join("/srv", c.App.Name)
|
|
}
|
|
|
|
// GetRawResourceStats returns RAW CPU and memory usage directly from Docker API
|
|
func (c *Container) GetRawResourceStats() (int64, int, error) {
|
|
driver := c.getDriver()
|
|
cpu, memory, err := driver.RawStats(c.App.Name)
|
|
return cpu, memory, err
|
|
}
|
|
|
|
// GetState returns app state object with populated state fields
|
|
func (c *Container) GetState() (*apps.AppState, error) {
|
|
status, err := c.Status()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
cpu, memory, err := c.ResourceUsage()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
bytes, inodes, err := c.DiskUsage()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
state := apps.AppState{
|
|
State: status,
|
|
CPUUsage: cpu,
|
|
MemoryUsage: memory,
|
|
DiskUsageBytes: bytes,
|
|
DiskUsageInodes: inodes,
|
|
}
|
|
|
|
return &state, nil
|
|
}
|
|
|
|
// Status returns state of the container
|
|
// Possible values: running, stopped, no-container, unknown
|
|
func (c *Container) Status() (string, error) {
|
|
status := "unknown"
|
|
|
|
// if _, err := os.Stat(path.Join("/srv", c.App.Name)); !os.IsNotExist(err) {
|
|
// status = "data-only"
|
|
// }
|
|
|
|
driver := c.getDriver()
|
|
containerStatus, err := driver.Status(c.App.Name)
|
|
if err != nil && err.Error() == "no container found" {
|
|
return "no-container", nil
|
|
}
|
|
if err != nil {
|
|
return status, err
|
|
}
|
|
|
|
status = containerStatus
|
|
|
|
return status, nil
|
|
}
|
|
|
|
// DiskUsage returns number of bytes and inodes used by the container in it's mounted volume
|
|
func (c *Container) DiskUsage() (int, int, error) {
|
|
return du(c.volumeHostPath())
|
|
}
|
|
|
|
// ResourceUsage returns amount of memory in B and CPU in % that the app occupies
|
|
func (c *Container) ResourceUsage() (float64, int, error) {
|
|
driver := c.getDriver()
|
|
|
|
cpu, memory, err := driver.Stats(c.App.Name)
|
|
if err != nil {
|
|
return 0.0, 0, err
|
|
}
|
|
|
|
return cpu, memory, nil
|
|
}
|
|
|
|
// Create creates the container
|
|
func (c *Container) Create() error {
|
|
driver := c.getDriver()
|
|
_, err := driver.Create(
|
|
c.App.Name,
|
|
c.App.Image,
|
|
c.volumeHostPath(),
|
|
c.App.HTTPPort,
|
|
c.App.SSHPort,
|
|
c.App.CPU,
|
|
c.App.Memory,
|
|
[]string{},
|
|
)
|
|
|
|
return err
|
|
}
|
|
|
|
// Start starts the container
|
|
func (c *Container) Start() error {
|
|
driver := c.getDriver()
|
|
|
|
return driver.Start(c.App.Name)
|
|
}
|
|
|
|
// Stop stops the container
|
|
func (c *Container) Stop() error {
|
|
driver := c.getDriver()
|
|
|
|
return driver.Stop(c.App.Name)
|
|
}
|
|
|
|
// Restart restarts the container
|
|
func (c *Container) Restart() error {
|
|
driver := c.getDriver()
|
|
|
|
err := driver.Stop(c.App.Name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return driver.Start(c.App.Name)
|
|
}
|
|
|
|
// Destroy removes the container but keeps the data so it can be created again
|
|
func (c *Container) Destroy() error {
|
|
driver := c.getDriver()
|
|
|
|
return driver.Remove(c.App.Name)
|
|
}
|
|
|
|
// Delete removes both data and the container
|
|
func (c *Container) Delete() error {
|
|
err := c.Destroy()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
volumePath := path.Join("/srv", c.App.Name)
|
|
err = removeDirectory(volumePath)
|
|
if err != nil {
|
|
log.Println(err)
|
|
}
|
|
|
|
return nil
|
|
}
|