mirror of
https://github.com/docker/compose.git
synced 2025-05-10 09:30:11 +02:00
121 lines
3.5 KiB
Go
121 lines
3.5 KiB
Go
package proxy
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
|
|
"github.com/docker/api/containers"
|
|
containersv1 "github.com/docker/api/protos/containers/v1"
|
|
"github.com/docker/api/server/proxy/streams"
|
|
)
|
|
|
|
func portsToGrpc(ports []containers.Port) []*containersv1.Port {
|
|
var result []*containersv1.Port
|
|
for _, port := range ports {
|
|
result = append(result, &containersv1.Port{
|
|
ContainerPort: port.ContainerPort,
|
|
HostPort: port.HostPort,
|
|
HostIp: port.HostIP,
|
|
Protocol: port.Protocol,
|
|
})
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
func (p *proxy) List(ctx context.Context, request *containersv1.ListRequest) (*containersv1.ListResponse, error) {
|
|
containerList, err := Client(ctx).ContainerService().List(ctx, request.GetAll())
|
|
if err != nil {
|
|
return &containersv1.ListResponse{}, err
|
|
}
|
|
|
|
response := &containersv1.ListResponse{
|
|
Containers: []*containersv1.Container{},
|
|
}
|
|
for _, container := range containerList {
|
|
response.Containers = append(response.Containers, toGrpcContainer(container))
|
|
}
|
|
|
|
return response, nil
|
|
}
|
|
|
|
func (p *proxy) Stop(ctx context.Context, request *containersv1.StopRequest) (*containersv1.StopResponse, error) {
|
|
timeoutValue := request.GetTimeout()
|
|
return &containersv1.StopResponse{}, Client(ctx).ContainerService().Stop(ctx, request.Id, &timeoutValue)
|
|
}
|
|
|
|
func (p *proxy) Run(ctx context.Context, request *containersv1.RunRequest) (*containersv1.RunResponse, error) {
|
|
ports := []containers.Port{}
|
|
for _, p := range request.GetPorts() {
|
|
ports = append(ports, containers.Port{
|
|
ContainerPort: p.ContainerPort,
|
|
HostIP: p.HostIp,
|
|
HostPort: p.HostPort,
|
|
Protocol: p.Protocol,
|
|
})
|
|
}
|
|
|
|
return &containersv1.RunResponse{}, Client(ctx).ContainerService().Run(ctx, containers.ContainerConfig{
|
|
ID: request.GetId(),
|
|
Image: request.GetImage(),
|
|
Labels: request.GetLabels(),
|
|
Ports: ports,
|
|
Volumes: request.GetVolumes(),
|
|
})
|
|
}
|
|
|
|
func (p *proxy) Inspect(ctx context.Context, request *containersv1.InspectRequest) (*containersv1.InspectResponse, error) {
|
|
c, err := Client(ctx).ContainerService().Inspect(ctx, request.Id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
response := &containersv1.InspectResponse{
|
|
Container: toGrpcContainer(c),
|
|
}
|
|
return response, err
|
|
}
|
|
|
|
func (p *proxy) Delete(ctx context.Context, request *containersv1.DeleteRequest) (*containersv1.DeleteResponse, error) {
|
|
return &containersv1.DeleteResponse{}, Client(ctx).ContainerService().Delete(ctx, request.Id, request.Force)
|
|
}
|
|
|
|
func (p *proxy) Exec(ctx context.Context, request *containersv1.ExecRequest) (*containersv1.ExecResponse, error) {
|
|
p.mu.Lock()
|
|
stream, ok := p.streams[request.StreamId]
|
|
p.mu.Unlock()
|
|
if !ok {
|
|
return &containersv1.ExecResponse{}, errors.New("unknown stream id")
|
|
}
|
|
|
|
io := &streams.IO{
|
|
Stream: stream,
|
|
}
|
|
|
|
return &containersv1.ExecResponse{}, Client(ctx).ContainerService().Exec(ctx, request.GetId(), request.GetCommand(), io, io)
|
|
}
|
|
|
|
func (p *proxy) Logs(request *containersv1.LogsRequest, stream containersv1.Containers_LogsServer) error {
|
|
return Client(stream.Context()).ContainerService().Logs(stream.Context(), request.GetContainerId(), containers.LogsRequest{
|
|
Follow: request.Follow,
|
|
Writer: &streams.Log{
|
|
Stream: stream,
|
|
},
|
|
})
|
|
}
|
|
|
|
func toGrpcContainer(c containers.Container) *containersv1.Container {
|
|
return &containersv1.Container{
|
|
Id: c.ID,
|
|
Image: c.Image,
|
|
Status: c.Status,
|
|
Command: c.Command,
|
|
CpuTime: c.CPUTime,
|
|
MemoryUsage: c.MemoryUsage,
|
|
MemoryLimit: c.MemoryLimit,
|
|
PidsCurrent: c.PidsCurrent,
|
|
PidsLimit: c.PidsLimit,
|
|
Labels: c.Labels,
|
|
Ports: portsToGrpc(c.Ports),
|
|
}
|
|
}
|