mirror of
https://github.com/yusing/godoxy.git
synced 2025-05-20 12:42:34 +02:00
90 lines
2.7 KiB
Go
90 lines
2.7 KiB
Go
package provider
|
|
|
|
import (
|
|
"context"
|
|
|
|
"github.com/docker/docker/api/types/container"
|
|
"github.com/yusing/go-proxy/internal/docker"
|
|
"github.com/yusing/go-proxy/internal/gperr"
|
|
idlewatcher "github.com/yusing/go-proxy/internal/idlewatcher/types"
|
|
"github.com/yusing/go-proxy/internal/watcher"
|
|
)
|
|
|
|
type DockerProvider struct {
|
|
client *docker.SharedClient
|
|
watcher *watcher.DockerWatcher
|
|
containerID string
|
|
}
|
|
|
|
var startOptions = container.StartOptions{}
|
|
|
|
func NewDockerProvider(dockerHost, containerID string) (idlewatcher.Provider, error) {
|
|
client, err := docker.NewClient(dockerHost)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &DockerProvider{
|
|
client: client,
|
|
watcher: watcher.NewDockerWatcher(dockerHost),
|
|
containerID: containerID,
|
|
}, nil
|
|
}
|
|
|
|
func (p *DockerProvider) ContainerPause(ctx context.Context) error {
|
|
return p.client.ContainerPause(ctx, p.containerID)
|
|
}
|
|
|
|
func (p *DockerProvider) ContainerUnpause(ctx context.Context) error {
|
|
return p.client.ContainerUnpause(ctx, p.containerID)
|
|
}
|
|
|
|
func (p *DockerProvider) ContainerStart(ctx context.Context) error {
|
|
return p.client.ContainerStart(ctx, p.containerID, startOptions)
|
|
}
|
|
|
|
func (p *DockerProvider) ContainerStop(ctx context.Context, signal idlewatcher.Signal, timeout int) error {
|
|
return p.client.ContainerStop(ctx, p.containerID, container.StopOptions{
|
|
Signal: string(signal),
|
|
Timeout: &timeout,
|
|
})
|
|
}
|
|
|
|
func (p *DockerProvider) ContainerKill(ctx context.Context, signal idlewatcher.Signal) error {
|
|
return p.client.ContainerKill(ctx, p.containerID, string(signal))
|
|
}
|
|
|
|
func (p *DockerProvider) ContainerStatus(ctx context.Context) (idlewatcher.ContainerStatus, error) {
|
|
status, err := p.client.ContainerInspect(ctx, p.containerID)
|
|
if err != nil {
|
|
return idlewatcher.ContainerStatusError, err
|
|
}
|
|
switch status.State.Status {
|
|
case "running":
|
|
return idlewatcher.ContainerStatusRunning, nil
|
|
case "exited", "dead", "restarting":
|
|
return idlewatcher.ContainerStatusStopped, nil
|
|
case "paused":
|
|
return idlewatcher.ContainerStatusPaused, nil
|
|
}
|
|
return idlewatcher.ContainerStatusError, idlewatcher.ErrUnexpectedContainerStatus.Subject(status.State.Status)
|
|
}
|
|
|
|
func (p *DockerProvider) Watch(ctx context.Context) (eventCh <-chan watcher.Event, errCh <-chan gperr.Error) {
|
|
return p.watcher.EventsWithOptions(ctx, watcher.DockerListOptions{
|
|
Filters: watcher.NewDockerFilter(
|
|
watcher.DockerFilterContainer,
|
|
watcher.DockerFilterContainerNameID(p.containerID),
|
|
watcher.DockerFilterStart,
|
|
watcher.DockerFilterStop,
|
|
watcher.DockerFilterDie,
|
|
watcher.DockerFilterKill,
|
|
watcher.DockerFilterDestroy,
|
|
watcher.DockerFilterPause,
|
|
watcher.DockerFilterUnpause,
|
|
),
|
|
})
|
|
}
|
|
|
|
func (p *DockerProvider) Close() {
|
|
p.client.Close()
|
|
}
|