@@ -125,7 +125,7 @@ github.com/containerd/continuity                    004b46473808b3e7a4a3049c20e4

 github.com/containerd/cgroups                       4994991857f9b0ae8dc439551e8bebdbb4bf66c1

 github.com/containerd/console                       c12b1e7919c14469339a5d38f2f8ed9b64a9de23

 github.com/containerd/go-runc                       5a6d9f37cfa36b15efba46dc7ea349fa9b7143c3

-github.com/containerd/typeurl                       a93fcdb778cd272c6e9b3028b2f42d813e785d40

+github.com/containerd/typeurl                       2a93cfde8c20b23de8eb84a5adbc234ddf7a9e8d

 github.com/containerd/ttrpc                         f02858b1457c5ca3aaec3a0803eb0d59f96e41d6

 github.com/gogo/googleapis                          08a7655d27152912db7aaf4f983275eaf8d128ef

@@ -1,6 +1,7 @@

+

                                  Apache License

                            Version 2.0, January 2004

-                        http://www.apache.org/licenses/

+                        https://www.apache.org/licenses/

    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

@@ -175,24 +176,13 @@

    END OF TERMS AND CONDITIONS

-   APPENDIX: How to apply the Apache License to your work.

-

-      To apply the Apache License to your work, attach the following

-      boilerplate notice, with the fields enclosed by brackets "[]"

-      replaced with your own identifying information. (Don't include

-      the brackets!)  The text should be enclosed in the appropriate

-      comment syntax for the file format. We also recommend that a

-      file or class name and description of purpose be included on the

-      same "printed page" as the copyright notice for easier

-      identification within third-party archives.

-

-   Copyright [yyyy] [name of copyright owner]

+   Copyright The containerd Authors

    Licensed under the Apache License, Version 2.0 (the "License");

    you may not use this file except in compliance with the License.

    You may obtain a copy of the License at

-       http://www.apache.org/licenses/LICENSE-2.0

+       https://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software

    distributed under the License is distributed on an "AS IS" BASIS,

@@ -7,3 +7,13 @@

 A Go package for managing the registration, marshaling, and unmarshaling of encoded types.

 This package helps when types are sent over a GRPC API and marshaled as a [protobuf.Any]().

+

+## Project details

+

+**typeurl** is a containerd sub-project, licensed under the [Apache 2.0 license](./LICENSE).

+As a containerd sub-project, you will find the:

+ * [Project governance](https://github.com/containerd/project/blob/master/GOVERNANCE.md),

+ * [Maintainers](https://github.com/containerd/project/blob/master/MAINTAINERS),

+ * and [Contributing guidelines](https://github.com/containerd/project/blob/master/CONTRIBUTING.md)

+

+information in our [`containerd/project`](https://github.com/containerd/project) repository.

new file mode 100644

@@ -0,0 +1,83 @@

+/*

+   Copyright The containerd Authors.

+

+   Licensed under the Apache License, Version 2.0 (the "License");

+   you may not use this file except in compliance with the License.

+   You may obtain a copy of the License at

+

+       http://www.apache.org/licenses/LICENSE-2.0

+

+   Unless required by applicable law or agreed to in writing, software

+   distributed under the License is distributed on an "AS IS" BASIS,

+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+   See the License for the specific language governing permissions and

+   limitations under the License.

+*/

+

+package typeurl

+

+// Package typeurl assists with managing the registration, marshaling, and

+// unmarshaling of types encoded as protobuf.Any.

+//

+// A protobuf.Any is a proto message that can contain any arbitrary data. It

+// consists of two components, a TypeUrl and a Value, and its proto definition

+// looks like this:

+//

+//   message Any {

+//     string type_url = 1;

+//     bytes value = 2;

+//   }

+//

+// The TypeUrl is used to distinguish the contents from other proto.Any

+// messages. This typeurl library manages these URLs to enable automagic

+// marshaling and unmarshaling of the contents.

+//

+// For example, consider this go struct:

+//

+//   type Foo struct {

+//     Field1 string

+//     Field2 string

+//   }

+//

+// To use typeurl, types must first be registered. This is typically done in

+// the init function

+//

+//   func init() {

+//      typeurl.Register(&Foo{}, "Foo")

+//   }

+//

+// This will register the type Foo with the url path "Foo". The arguments to

+// Register are variadic, and are used to construct a url path. Consider this

+// example, from the github.com/containerd/containerd/client package:

+//

+//   func init() {

+//     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")

+//     // this function has more Register calls, which are elided.

+//   }

+//

+// This registers several types under a more complex url, which ends up mapping

+// to `types.containerd.io/opencontainers/runtime-spec/1/Spec` (or some other

+// value for major).

+//

+// Once a type is registered, it can be marshaled to a proto.Any message simply

+// by calling `MarshalAny`, like this:

+//

+//   foo := &Foo{Field1: "value1", Field2: "value2"}

+//   anyFoo, err := typeurl.MarshalAny(foo)

+//

+// MarshalAny will resolve the correct URL for the type. If the type in

+// question implements the proto.Message interface, then it will be marshaled

+// as a proto message. Otherwise, it will be marshaled as json. This means that

+// typeurl will work on any arbitrary data, whether or not it has a proto

+// definition, as long as it can be serialized to json.

+//

+// To unmarshal, the process is simply inverse:

+//

+//   iface, err := typeurl.UnmarshalAny(anyFoo)

+//   foo := iface.(*Foo)

+//

+// The correct type is automatically chosen from the type registry, and the

+// returned interface can be cast straight to that type.

@@ -78,7 +78,10 @@ func Is(any *types.Any, v interface{}) bool {

 	return any.TypeUrl == url

 }

-// MarshalAny marshals the value v into an any with the correct TypeUrl

+// MarshalAny marshals the value v into an any with the correct TypeUrl.

+// If the provided object is already a proto.Any message, then it will be

+// returned verbatim. If it is of type proto.Message, it will be marshaled as a

+// protocol buffer. Otherwise, the object will be marshaled to json.

 func MarshalAny(v interface{}) (*types.Any, error) {

 	var marshal func(v interface{}) ([]byte, error)

 	switch t := v.(type) {