193abed96e
The split between provider and ingester was a long standing division reflecting the client-side use cases. For the most part, we were differentiating these for the algorithms that operate them, but it made instantation and use of the types challenging. On the server-side, this distinction is generally less important. This change unifies these types and in the process we get a few benefits. The first is that we now completely access the content store over GRPC. This was the initial intent and we have now satisfied this goal completely. There are a few issues around listing content and getting status, but we resolve these with simple streaming and regexp filters. More can probably be done to polish this but the result is clean. Several other content-oriented methods were polished in the process of unification. We have now properly seperated out the `Abort` method to cancel ongoing or stalled ingest processes. We have also replaced the `Active` method with a single status method. The transition went extremely smoothly. Once the clients were updated to use the new methods, every thing worked as expected on the first compile. Signed-off-by: Stephen J Day <stephen.day@docker.com>
132 lines
3.2 KiB
Go
132 lines
3.2 KiB
Go
package main
|
|
|
|
import (
|
|
gocontext "context"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"os"
|
|
"os/signal"
|
|
"path/filepath"
|
|
"strconv"
|
|
"strings"
|
|
"syscall"
|
|
|
|
"github.com/Sirupsen/logrus"
|
|
contentapi "github.com/containerd/containerd/api/services/content"
|
|
"github.com/containerd/containerd/api/services/execution"
|
|
imagesapi "github.com/containerd/containerd/api/services/images"
|
|
rootfsapi "github.com/containerd/containerd/api/services/rootfs"
|
|
"github.com/containerd/containerd/api/types/container"
|
|
"github.com/containerd/containerd/content"
|
|
"github.com/containerd/containerd/images"
|
|
contentservice "github.com/containerd/containerd/services/content"
|
|
imagesservice "github.com/containerd/containerd/services/images"
|
|
"github.com/urfave/cli"
|
|
"google.golang.org/grpc"
|
|
)
|
|
|
|
var grpcConn *grpc.ClientConn
|
|
|
|
func getExecutionService(context *cli.Context) (execution.ContainerServiceClient, error) {
|
|
conn, err := getGRPCConnection(context)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return execution.NewContainerServiceClient(conn), nil
|
|
}
|
|
|
|
func getContentStore(context *cli.Context) (content.Store, error) {
|
|
conn, err := getGRPCConnection(context)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return contentservice.NewStoreFromClient(contentapi.NewContentClient(conn)), nil
|
|
}
|
|
|
|
func getRootFSService(context *cli.Context) (rootfsapi.RootFSClient, error) {
|
|
conn, err := getGRPCConnection(context)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return rootfsapi.NewRootFSClient(conn), nil
|
|
}
|
|
|
|
func getImageStore(clicontext *cli.Context) (images.Store, error) {
|
|
conn, err := getGRPCConnection(clicontext)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return imagesservice.NewStoreFromClient(imagesapi.NewImagesClient(conn)), nil
|
|
}
|
|
|
|
func getTempDir(id string) (string, error) {
|
|
err := os.MkdirAll(filepath.Join(os.TempDir(), "ctr"), 0700)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
tmpDir, err := ioutil.TempDir(filepath.Join(os.TempDir(), "ctr"), fmt.Sprintf("%s-", id))
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return tmpDir, nil
|
|
}
|
|
|
|
func waitContainer(events execution.ContainerService_EventsClient, id string, pid uint32) (uint32, error) {
|
|
for {
|
|
e, err := events.Recv()
|
|
if err != nil {
|
|
return 255, err
|
|
}
|
|
if e.Type != container.Event_EXIT {
|
|
continue
|
|
}
|
|
if e.ID == id && e.Pid == pid {
|
|
return e.ExitStatus, nil
|
|
}
|
|
}
|
|
}
|
|
|
|
func forwardAllSignals(containers execution.ContainerServiceClient, id string) chan os.Signal {
|
|
sigc := make(chan os.Signal, 128)
|
|
signal.Notify(sigc)
|
|
|
|
go func() {
|
|
for s := range sigc {
|
|
logrus.Debug("Forwarding signal ", s)
|
|
killRequest := &execution.KillRequest{
|
|
ID: id,
|
|
Signal: uint32(s.(syscall.Signal)),
|
|
All: false,
|
|
}
|
|
_, err := containers.Kill(gocontext.Background(), killRequest)
|
|
if err != nil {
|
|
logrus.Fatalln(err)
|
|
}
|
|
}
|
|
}()
|
|
return sigc
|
|
}
|
|
|
|
func parseSignal(rawSignal string) (syscall.Signal, error) {
|
|
s, err := strconv.Atoi(rawSignal)
|
|
if err == nil {
|
|
sig := syscall.Signal(s)
|
|
for _, msig := range signalMap {
|
|
if sig == msig {
|
|
return sig, nil
|
|
}
|
|
}
|
|
return -1, fmt.Errorf("unknown signal %q", rawSignal)
|
|
}
|
|
signal, ok := signalMap[strings.TrimPrefix(strings.ToUpper(rawSignal), "SIG")]
|
|
if !ok {
|
|
return -1, fmt.Errorf("unknown signal %q", rawSignal)
|
|
}
|
|
return signal, nil
|
|
}
|
|
|
|
func stopCatch(sigc chan os.Signal) {
|
|
signal.Stop(sigc)
|
|
close(sigc)
|
|
}
|