a615a6fe5d
In the course of setting out to add filters and address some cleanup, it was found that we had a few problems in the events subsystem that needed addressing before moving forward. The biggest change was to move to the more standard terminology of publish and subscribe. We make this terminology change across the Go interface and the GRPC API, making the behavior more familier. The previous system was very context-oriented, which is no longer required. With this, we've removed a large amount of dead and unneeded code. Event transactions, context storage and the concept of `Poster` is gone. This has been replaced in most places with a `Publisher`, which matches the actual usage throughout the codebase, removing the need for helpers. There are still some questions around the way events are handled in the shim. Right now, we've preserved some of the existing bugs which may require more extensive changes to resolve correctly. Signed-off-by: Stephen J Day <stephen.day@docker.com>
131 lines
2.8 KiB
Go
131 lines
2.8 KiB
Go
package containerd
|
|
|
|
import (
|
|
"context"
|
|
"syscall"
|
|
|
|
eventsapi "github.com/containerd/containerd/api/services/events/v1"
|
|
"github.com/containerd/containerd/api/services/tasks/v1"
|
|
"github.com/containerd/containerd/typeurl"
|
|
specs "github.com/opencontainers/runtime-spec/specs-go"
|
|
)
|
|
|
|
type process struct {
|
|
id string
|
|
task *task
|
|
pid uint32
|
|
io *IO
|
|
spec *specs.Process
|
|
}
|
|
|
|
func (p *process) ID() string {
|
|
return p.id
|
|
}
|
|
|
|
// Pid returns the pid of the process
|
|
// The pid is not set until start is called and returns
|
|
func (p *process) Pid() uint32 {
|
|
return p.pid
|
|
}
|
|
|
|
// Start starts the exec process
|
|
func (p *process) Start(ctx context.Context) error {
|
|
any, err := typeurl.MarshalAny(p.spec)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
request := &tasks.ExecProcessRequest{
|
|
ContainerID: p.task.id,
|
|
ExecID: p.id,
|
|
Terminal: p.io.Terminal,
|
|
Stdin: p.io.Stdin,
|
|
Stdout: p.io.Stdout,
|
|
Stderr: p.io.Stderr,
|
|
Spec: any,
|
|
}
|
|
response, err := p.task.client.TaskService().Exec(ctx, request)
|
|
if err != nil {
|
|
p.io.Cancel()
|
|
p.io.Wait()
|
|
p.io.Close()
|
|
return err
|
|
}
|
|
p.pid = response.Pid
|
|
return nil
|
|
}
|
|
|
|
func (p *process) Kill(ctx context.Context, s syscall.Signal) error {
|
|
_, err := p.task.client.TaskService().Kill(ctx, &tasks.KillRequest{
|
|
Signal: uint32(s),
|
|
ContainerID: p.task.id,
|
|
ExecID: p.id,
|
|
})
|
|
return err
|
|
}
|
|
|
|
func (p *process) Wait(ctx context.Context) (uint32, error) {
|
|
eventstream, err := p.task.client.EventService().Subscribe(ctx, &eventsapi.SubscribeRequest{})
|
|
if err != nil {
|
|
return UnknownExitStatus, err
|
|
}
|
|
for {
|
|
evt, err := eventstream.Recv()
|
|
if err != nil {
|
|
return UnknownExitStatus, err
|
|
}
|
|
if typeurl.Is(evt.Event, &eventsapi.TaskExit{}) {
|
|
v, err := typeurl.UnmarshalAny(evt.Event)
|
|
if err != nil {
|
|
return UnknownExitStatus, err
|
|
}
|
|
e := v.(*eventsapi.TaskExit)
|
|
if e.ID == p.id && e.ContainerID == p.task.id {
|
|
return e.ExitStatus, nil
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func (p *process) CloseIO(ctx context.Context, opts ...IOCloserOpts) error {
|
|
r := &tasks.CloseIORequest{
|
|
ContainerID: p.task.id,
|
|
ExecID: p.id,
|
|
}
|
|
var i IOCloseInfo
|
|
for _, o := range opts {
|
|
o(&i)
|
|
}
|
|
r.Stdin = i.Stdin
|
|
_, err := p.task.client.TaskService().CloseIO(ctx, r)
|
|
return err
|
|
}
|
|
|
|
func (p *process) IO() *IO {
|
|
return p.io
|
|
}
|
|
|
|
func (p *process) Resize(ctx context.Context, w, h uint32) error {
|
|
_, err := p.task.client.TaskService().ResizePty(ctx, &tasks.ResizePtyRequest{
|
|
ContainerID: p.task.id,
|
|
Width: w,
|
|
Height: h,
|
|
ExecID: p.id,
|
|
})
|
|
return err
|
|
}
|
|
|
|
func (p *process) Delete(ctx context.Context) (uint32, error) {
|
|
if p.io != nil {
|
|
p.io.Wait()
|
|
p.io.Close()
|
|
}
|
|
r, err := p.task.client.TaskService().DeleteProcess(ctx, &tasks.DeleteProcessRequest{
|
|
ContainerID: p.task.id,
|
|
ExecID: p.id,
|
|
})
|
|
if err != nil {
|
|
return UnknownExitStatus, err
|
|
}
|
|
return r.ExitStatus, nil
|
|
}
|