const prefix = "types.containerd.io"

// register TypeUrls for commonly marshaled external types

major := strconv.Itoa(specs.VersionMajor)

typeurl.Register(&specs.Spec{}, prefix, "opencontainers/runtime-spec", major, "Spec")

typeurl.Register(&specs.Process{}, prefix, "opencontainers/runtime-spec", major, "Process")

typeurl.Register(&specs.LinuxResources{}, prefix, "opencontainers/runtime-spec", major, "LinuxResources")

typeurl.Register(&specs.WindowsResources{}, prefix, "opencontainers/runtime-spec", major, "WindowsResources")

var copts clientOpts

for _, o := range opts {

if err := o(&copts); err != nil {

return nil, err

}

}

if copts.timeout == 0 {

copts.timeout = 10 * time.Second

}

c := &Client{

defaultns: copts.defaultns,

}

if copts.defaultRuntime != "" {

c.runtime = copts.defaultRuntime

} else {

c.runtime = defaults.DefaultRuntime

}

if copts.defaultPlatform != nil {

c.platform = copts.defaultPlatform

} else {

c.platform = platforms.Default()

}

if copts.services != nil {

c.services = *copts.services

}

if address != "" {

backoffConfig := backoff.DefaultConfig

backoffConfig.MaxDelay = 3 * time.Second

connParams := grpc.ConnectParams{

Backoff: backoffConfig,

}

gopts := []grpc.DialOption{

grpc.WithBlock(),

grpc.WithTransportCredentials(insecure.NewCredentials()),

grpc.FailOnNonTempDialError(true),

grpc.WithConnectParams(connParams),

grpc.WithContextDialer(dialer.ContextDialer),

grpc.WithReturnConnectionError(),

}

if len(copts.dialOptions) > 0 {

gopts = copts.dialOptions

}

gopts = append(gopts, grpc.WithDefaultCallOptions(

grpc.MaxCallRecvMsgSize(defaults.DefaultMaxRecvMsgSize),

grpc.MaxCallSendMsgSize(defaults.DefaultMaxSendMsgSize)))

if len(copts.callOptions) > 0 {

gopts = append(gopts, grpc.WithDefaultCallOptions(copts.callOptions...))

}

if copts.defaultns != "" {

unary, stream := newNSInterceptors(copts.defaultns)

gopts = append(gopts, grpc.WithChainUnaryInterceptor(unary))

gopts = append(gopts, grpc.WithChainStreamInterceptor(stream))

}

connector := func() (*grpc.ClientConn, error) {

ctx, cancel := context.WithTimeout(context.Background(), copts.timeout)

defer cancel()

conn, err := grpc.DialContext(ctx, dialer.DialAddress(address), gopts...)

if err != nil {

return nil, fmt.Errorf("failed to dial %q: %w", address, err)

}

return conn, nil

}

conn, err := connector()

if err != nil {

return nil, err

}

c.conn, c.connector = conn, connector

}

if copts.services == nil && c.conn == nil {

return nil, fmt.Errorf("no grpc connection or services is available: %w", errdefs.ErrUnavailable)

}

// check namespace labels for default runtime

if copts.defaultRuntime == "" && c.defaultns != "" {

if label, err := c.GetLabel(context.Background(), defaults.DefaultRuntimeNSLabel); err != nil {

return nil, err

} else if label != "" {

c.runtime = label

}

}

return c, nil

var copts clientOpts

for _, o := range opts {

if err := o(&copts); err != nil {

return nil, err

}

}

c := &Client{

defaultns: copts.defaultns,

conn: conn,

runtime: fmt.Sprintf("%s.%s", plugin.RuntimePlugin, runtime.GOOS),

}

// check namespace labels for default runtime

if copts.defaultRuntime == "" && c.defaultns != "" {

if label, err := c.GetLabel(context.Background(), defaults.DefaultRuntimeNSLabel); err != nil {

return nil, err

} else if label != "" {

c.runtime = label

}

}

if copts.services != nil {

c.services = *copts.services

}

return c, nil

services

connMu sync.Mutex

conn *grpc.ClientConn

runtime string

defaultns string

platform platforms.MatchComparer

connector func() (*grpc.ClientConn, error)

if c.connector == nil {

return fmt.Errorf("unable to reconnect to containerd, no connector available: %w", errdefs.ErrUnavailable)

}

c.connMu.Lock()

defer c.connMu.Unlock()

c.conn.Close()

conn, err := c.connector()

if err != nil {

return err

}

c.conn = conn

return nil

c.connMu.Lock()

if c.conn == nil {

c.connMu.Unlock()

return false, fmt.Errorf("no grpc connection available: %w", errdefs.ErrUnavailable)

}

c.connMu.Unlock()

r, err := c.HealthService().Check(ctx, &grpc_health_v1.HealthCheckRequest{}, grpc.WaitForReady(true))

if err != nil {

return false, err

}

return r.Status == grpc_health_v1.HealthCheckResponse_SERVING, nil

r, err := c.ContainerService().List(ctx, filters...)

if err != nil {

return nil, err

}

var out []Container

for _, container := range r {

out = append(out, containerFromRecord(c, container))

}

return out, nil

ctx, done, err := c.WithLease(ctx)

if err != nil {

return nil, err

}

defer done(ctx)

container := containers.Container{

ID: id,

Runtime: containers.RuntimeInfo{

Name: c.runtime,

},

}

for _, o := range opts {

if err := o(ctx, c, &container); err != nil {

return nil, err

}

}

r, err := c.ContainerService().Create(ctx, container)

if err != nil {

return nil, err

}

return containerFromRecord(c, r), nil

r, err := c.ContainerService().Get(ctx, id)

if err != nil {

return nil, err

}

return containerFromRecord(c, r), nil

// Resolver is used to resolve names to objects, fetchers, and pushers.

// If no resolver is provided, defaults to Docker registry resolver.

Resolver remotes.Resolver

// PlatformMatcher is used to match the platforms for an image

// operation and define the preference when a single match is required

// from multiple platforms.

PlatformMatcher platforms.MatchComparer

// Unpack is done after an image is pulled to extract into a snapshotter.

// It is done simultaneously for schema 2 images when they are pulled.

// If an image is not unpacked on pull, it can be unpacked any time

// afterwards. Unpacking is required to run an image.

Unpack bool

// UnpackOpts handles options to the unpack call.

UnpackOpts []UnpackOpt

// Snapshotter used for unpacking

Snapshotter string

// SnapshotterOpts are additional options to be passed to a snapshotter during pull

SnapshotterOpts []snapshots.Opt

// Labels to be applied to the created image

Labels map[string]string

// BaseHandlers are a set of handlers which get are called on dispatch.

// These handlers always get called before any operation specific

// handlers.

BaseHandlers []images.Handler

// HandlerWrapper wraps the handler which gets sent to dispatch.

// Unlike BaseHandlers, this can run before and after the built

// in handlers, allowing operations to run on the descriptor

// after it has completed transferring.

HandlerWrapper func(images.Handler) images.Handler

// ConvertSchema1 is whether to convert Docker registry schema 1

// manifests. If this option is false then any image which resolves

// to schema 1 will return an error since schema 1 is not supported.

//

// Deprecated: use Schema 2 or OCI images.

ConvertSchema1 bool

// Platforms defines which platforms to handle when doing the image operation.

// Platforms is ignored when a PlatformMatcher is set, otherwise the

// platforms will be used to create a PlatformMatcher with no ordering

// preference.

Platforms []string

// MaxConcurrentDownloads is the max concurrent content downloads for each pull.

MaxConcurrentDownloads int

// MaxConcurrentUploadedLayers is the max concurrent uploaded layers for each push.

MaxConcurrentUploadedLayers int

// AllMetadata downloads all manifests and known-configuration files

AllMetadata bool

// ChildLabelMap sets the labels used to reference child objects in the content

// store. By default, all GC reference labels will be set for all fetched content.

ChildLabelMap func(ocispec.Descriptor) []string

return &RemoteContext{

Resolver: docker.NewResolver(docker.ResolverOptions{}),

}

fetchCtx := defaultRemoteContext()

for _, o := range opts {

if err := o(c, fetchCtx); err != nil {

return images.Image{}, err

}

}

if fetchCtx.Unpack {

return images.Image{}, fmt.Errorf("unpack on fetch not supported, try pull: %w", errdefs.ErrNotImplemented)

}

if fetchCtx.PlatformMatcher == nil {

if len(fetchCtx.Platforms) == 0 {

fetchCtx.PlatformMatcher = platforms.All

} else {

var ps []ocispec.Platform

for _, s := range fetchCtx.Platforms {

p, err := platforms.Parse(s)

if err != nil {

return images.Image{}, fmt.Errorf("invalid platform %s: %w", s, err)

}

ps = append(ps, p)

}

fetchCtx.PlatformMatcher = platforms.Any(ps...)

}

}

ctx, done, err := c.WithLease(ctx)

if err != nil {

return images.Image{}, err

}

defer done(ctx)

img, err := c.fetch(ctx, fetchCtx, ref, 0)

if err != nil {

return images.Image{}, err

}

return c.createNewImage(ctx, img)

pushCtx := defaultRemoteContext()

for _, o := range opts {

if err := o(c, pushCtx); err != nil {

return err

}

}

if pushCtx.PlatformMatcher == nil {

if len(pushCtx.Platforms) > 0 {

var ps []ocispec.Platform

for _, platform := range pushCtx.Platforms {

p, err := platforms.Parse(platform)

if err != nil {

return fmt.Errorf("invalid platform %s: %w", platform, err)

}

ps = append(ps, p)

}

pushCtx.PlatformMatcher = platforms.Any(ps...)

} else {

pushCtx.PlatformMatcher = platforms.All

}

}

// Annotate ref with digest to push only push tag for single digest

if !strings.Contains(ref, "@") {

ref = ref + "@" + desc.Digest.String()

}

pusher, err := pushCtx.Resolver.Pusher(ctx, ref)

if err != nil {

return err

}

var wrapper func(images.Handler) images.Handler

if len(pushCtx.BaseHandlers) > 0 {

wrapper = func(h images.Handler) images.Handler {

h = images.Handlers(append(pushCtx.BaseHandlers, h)...)

if pushCtx.HandlerWrapper != nil {

h = pushCtx.HandlerWrapper(h)

}

return h

}

} else if pushCtx.HandlerWrapper != nil {

wrapper = pushCtx.HandlerWrapper

}

var limiter *semaphore.Weighted

if pushCtx.MaxConcurrentUploadedLayers > 0 {

limiter = semaphore.NewWeighted(int64(pushCtx.MaxConcurrentUploadedLayers))

}

return remotes.PushContent(ctx, pusher, desc, c.ContentStore(), limiter, pushCtx.PlatformMatcher, wrapper)

i, err := c.ImageService().Get(ctx, ref)

if err != nil {

return nil, err

}

return NewImage(c, i), nil

imgs, err := c.ImageService().List(ctx, filters...)

if err != nil {

return nil, err

}

images := make([]Image, len(imgs))

for i, img := range imgs {

images[i] = NewImage(c, img)

}

return images, nil

store := c.ContentStore()

index, err := decodeIndex(ctx, store, checkpoint.Target())

if err != nil {

return nil, err

}

ctx, done, err := c.WithLease(ctx)

if err != nil {

return nil, err

}

defer done(ctx)

copts := []NewContainerOpts{}

for _, o := range opts {

copts = append(copts, o(ctx, id, c, checkpoint, index))

}

ctr, err := c.NewContainer(ctx, id, copts...)

if err != nil {

return nil, err

}

return ctr, nil

labels := map[string]string{}

for i, m := range index.Manifests {

labels[fmt.Sprintf("containerd.io/gc.ref.content.%d", i)] = m.Digest.String()

}

data, err := json.Marshal(index)

if err != nil {

return ocispec.Descriptor{}, err

}

return writeContent(ctx, client.ContentStore(), ocispec.MediaTypeImageIndex, ref, bytes.NewReader(data), content.WithLabels(labels))

ns, err := namespaces.NamespaceRequired(ctx)

if err != nil {

if c.defaultns == "" {

return "", err

}

ns = c.defaultns

}

srv := c.NamespaceService()

labels, err := srv.Labels(ctx, ns)

if err != nil {

return "", err

}

value := labels[label]

return value, nil

c.connMu.Lock()

defer c.connMu.Unlock()

if c.conn != nil {

return c.conn.Close()

}

return nil

if c.namespaceStore != nil {

return c.namespaceStore

}

c.connMu.Lock()

defer c.connMu.Unlock()

return NewNamespaceStoreFromClient(namespacesapi.NewNamespacesClient(c.conn))

if c.containerStore != nil {

return c.containerStore

}

c.connMu.Lock()

defer c.connMu.Unlock()

return NewRemoteContainerStore(containersapi.NewContainersClient(c.conn))

if c.contentStore != nil {

return c.contentStore

}

c.connMu.Lock()

defer c.connMu.Unlock()

return contentproxy.NewContentStore(contentapi.NewContentClient(c.conn))

snapshotterName, err := c.resolveSnapshotterName(context.Background(), snapshotterName)

if err != nil {

snapshotterName = DefaultSnapshotter

}

if c.snapshotters != nil {

return c.snapshotters[snapshotterName]

}

c.connMu.Lock()

defer c.connMu.Unlock()

return snproxy.NewSnapshotter(snapshotsapi.NewSnapshotsClient(c.conn), snapshotterName)

if c.taskService != nil {

return c.taskService

}

c.connMu.Lock()

defer c.connMu.Unlock()

return tasks.NewTasksClient(c.conn)

if c.imageStore != nil {

return c.imageStore

}

c.connMu.Lock()

defer c.connMu.Unlock()

return NewImageStoreFromClient(imagesapi.NewImagesClient(c.conn))

if c.diffService != nil {

return c.diffService

}

c.connMu.Lock()

defer c.connMu.Unlock()

return NewDiffServiceFromClient(diffapi.NewDiffClient(c.conn))

if c.introspectionService != nil {

return c.introspectionService

}

c.connMu.Lock()

defer c.connMu.Unlock()

return introspection.NewIntrospectionServiceFromClient(introspectionapi.NewIntrospectionClient(c.conn))

if c.leasesService != nil {

return c.leasesService

}

c.connMu.Lock()

defer c.connMu.Unlock()

return leasesproxy.NewLeaseManager(leasesapi.NewLeasesClient(c.conn))

c.connMu.Lock()

defer c.connMu.Unlock()

return grpc_health_v1.NewHealthClient(c.conn)

if c.eventService != nil {

return c.eventService

}

c.connMu.Lock()

defer c.connMu.Unlock()

return NewEventServiceFromClient(eventsapi.NewEventsClient(c.conn))

if c.sandboxStore != nil {

return c.sandboxStore

}

c.connMu.Lock()

defer c.connMu.Unlock()

return NewRemoteSandboxStore(sandboxsapi.NewStoreClient(c.conn))

if c.sandboxController != nil {

return c.sandboxController

}

c.connMu.Lock()

defer c.connMu.Unlock()

return NewSandboxRemoteController(sandboxsapi.NewControllerClient(c.conn))

c.connMu.Lock()

defer c.connMu.Unlock()

return versionservice.NewVersionClient(c.conn)

c.connMu.Lock()

defer c.connMu.Unlock()

return c.conn

// Version number

Version string

// Revision from git that was built

Revision string

c.connMu.Lock()

if c.conn == nil {

c.connMu.Unlock()

return Version{}, fmt.Errorf("no grpc connection available: %w", errdefs.ErrUnavailable)

}

c.connMu.Unlock()

response, err := c.VersionService().Version(ctx, &ptypes.Empty{})

if err != nil {

return Version{}, err

}

return Version{

Version: response.Version,

Revision: response.Revision,

}, nil

c.connMu.Lock()

if c.conn == nil {

c.connMu.Unlock()

return ServerInfo{}, fmt.Errorf("no grpc connection available: %w", errdefs.ErrUnavailable)

}

c.connMu.Unlock()

response, err := c.IntrospectionService().Server(ctx, &ptypes.Empty{})

if err != nil {

return ServerInfo{}, err

}

return ServerInfo{

UUID: response.UUID,

}, nil

if name == "" {

label, err := c.GetLabel(ctx, defaults.DefaultSnapshotterNSLabel)

if err != nil {

return "", err

}

if label != "" {

name = label

} else {

name = DefaultSnapshotter

}

}

return name, nil

name, err := c.resolveSnapshotterName(ctx, name)

if err != nil {

return nil, err

}

s := c.SnapshotService(name)

if s == nil {

return nil, fmt.Errorf("snapshotter %s was not found: %w", name, errdefs.ErrNotFound)

}

return s, nil

cp := strings.Split(current, ".")

l := len(cp)

for i, p := range strings.Split(expected, ".") {

if i > l {

return false

}

if p != cp[i] {

return false

}

}

return true

filters := []string{fmt.Sprintf("type==%s, id==%s", plugin.SnapshotPlugin, snapshotterName)}

in := c.IntrospectionService()

resp, err := in.Plugins(ctx, filters)

if err != nil {

return nil, err

}

if len(resp.Plugins) <= 0 {

return nil, fmt.Errorf("inspection service could not find snapshotter %s plugin", snapshotterName)

}

sn := resp.Plugins[0]

snPlatforms := toPlatforms(sn.Platforms)

return platforms.Any(snPlatforms...), nil

platforms := make([]ocispec.Platform, len(pt))

for i, p := range pt {

platforms[i] = ocispec.Platform{

Architecture: p.Architecture,

OS: p.OS,

Variant: p.Variant,

}

}

return platforms