Documentation
¶
Overview ¶
Defines conversions between generic types and structs to map query strings to struct objects.
Package runtime includes helper functions for working with API objects that follow the kubernetes API object conventions, which are:
- Your API objects have a common metadata struct member, TypeMeta.
- Your code refers to an internal set of API objects.
- In a separate package, you have an external set of API objects.
- The external set is considered to be versioned, and no breaking changes are ever made to it (fields may be added but not changed or removed).
- As your api evolves, you'll make an additional versioned package with every major change.
- Versioned packages have conversion functions which convert to and from the internal version.
- You'll continue to support older versions according to your deprecation policy, and you can easily provide a program/library to update old versions into new versions because of 5.
- All of your serializations and deserializations are handled in a centralized place.
Package runtime provides a conversion helper to make 5 easy, and the Encode/Decode/DecodeInto trio to accomplish 7. You can also register additional "codecs" which use a version of your choice. It's recommended that you register your types with runtime in your package's init function.
As a bonus, a few common types useful from all api objects and versions are provided in types.go.
Index ¶
- Variables
- func DecodeList(objects []Object, decoders ...ObjectDecoder) []error
- func EncodeOrDie(codec Codec, obj Object) string
- func FieldPtr(v reflect.Value, fieldName string, dest interface{}) error
- func GetItemsPtr(list Object) (interface{}, error)
- func IsListType(obj Object) bool
- func IsMissingKind(err error) bool
- func IsMissingVersion(err error) bool
- func IsNotRegisteredError(err error) bool
- func JSONKeyMapper(key string, sourceTag, destTag reflect.StructTag) (string, string)
- func SetList(list Object, objects []Object) error
- func VerifySwaggerDocsExist(kubeTypes []KubeTypes, w io.Writer) (int, error)
- func WriteSwaggerDocFunc(kubeTypes []KubeTypes, w io.Writer) error
- type Codec
- type ConversionGenerator
- type Decoder
- type DeepCopyGenerator
- type EmbeddedObject
- type Encoder
- type FieldLabelConversionFunc
- type KubeTypes
- type MultiObjectTyper
- type Object
- type ObjectCodec
- type ObjectConvertor
- type ObjectCopier
- type ObjectCreater
- type ObjectDecoder
- type ObjectEncoder
- type ObjectScheme
- type ObjectTyper
- type Pair
- type PluginBase
- type RawExtension
- type ResourceVersioner
- type Scheme
- func (s *Scheme) AddConversionFuncs(conversionFuncs ...interface{}) error
- func (s *Scheme) AddDeepCopyFuncs(deepCopyFuncs ...interface{}) error
- func (s *Scheme) AddDefaultingFuncs(defaultingFuncs ...interface{}) error
- func (s *Scheme) AddFieldLabelConversionFunc(version, kind string, conversionFunc FieldLabelConversionFunc) error
- func (s *Scheme) AddGeneratedConversionFuncs(conversionFuncs ...interface{}) error
- func (s *Scheme) AddGeneratedDeepCopyFuncs(deepCopyFuncs ...interface{}) error
- func (s *Scheme) AddKnownTypeWithName(version, kind string, obj Object)
- func (s *Scheme) AddKnownTypes(version string, types ...Object)
- func (s *Scheme) AddStructFieldConversion(srcFieldType interface{}, srcFieldName string, destFieldType interface{}, ...) error
- func (s *Scheme) Convert(in, out interface{}) error
- func (s *Scheme) ConvertFieldLabel(version, kind, label, value string) (string, string, error)
- func (s *Scheme) ConvertToVersion(in Object, outVersion string) (Object, error)
- func (s *Scheme) Copy(src Object) (Object, error)
- func (s *Scheme) CopyOrDie(obj Object) Object
- func (s *Scheme) DataVersionAndKind(data []byte) (version, kind string, err error)
- func (s *Scheme) Decode(data []byte) (Object, error)
- func (s *Scheme) DecodeInto(data []byte, obj Object) error
- func (s *Scheme) DecodeIntoWithSpecifiedVersionKind(data []byte, obj Object, version, kind string) error
- func (s *Scheme) DecodeToVersion(data []byte, version string) (Object, error)
- func (s *Scheme) DeepCopy(src interface{}) (interface{}, error)
- func (s *Scheme) EncodeToVersion(obj Object, destVersion string) (data []byte, err error)
- func (s *Scheme) EncodeToVersionStream(obj Object, destVersion string, stream io.Writer) error
- func (s *Scheme) KnownTypes(version string) map[string]reflect.Type
- func (s *Scheme) Log(l conversion.DebugLogger)
- func (s *Scheme) New(versionName, typeName string) (Object, error)
- func (s *Scheme) ObjectVersionAndKind(obj Object) (version, kind string, err error)
- func (self *Scheme) Raw() *conversion.Scheme
- func (s *Scheme) Recognizes(version, kind string) bool
- type SelfLinker
- type TypeMeta
- type Unknown
- type Unstructured
Constants ¶
This section is empty.
Variables ¶
var DefaultStringConversions = []interface{}{
convertStringSliceToString,
convertStringSliceToInt,
convertStringSliceToBool,
convertStringSliceToInt64,
}
DefaultStringConversions are helpers for converting []string and string to real values.
Functions ¶
func DecodeList ¶ added in v0.17.0
func DecodeList(objects []Object, decoders ...ObjectDecoder) []error
DecodeList alters the list in place, attempting to decode any objects found in the list that have the runtime.Unknown type. Any errors that occur are returned after the entire list is processed. Decoders are tried in order.
func EncodeOrDie ¶
EncodeOrDie is a version of Encode which will panic instead of returning an error. For tests.
func FieldPtr ¶ added in v0.10.1
fieldPtr puts the address of fieldName, which must be a member of v, into dest, which must be an address of a variable to which this field's address can be assigned.
func GetItemsPtr ¶
GetItemsPtr returns a pointer to the list object's Items member. If 'list' doesn't have an Items member, it's not really a list type and an error will be returned. This function will either return a pointer to a slice, or an error, but not both.
func IsListType ¶ added in v0.5.1
IsListType returns true if the provided Object has a slice called Items
func IsMissingKind ¶ added in v0.12.0
IsMissingKind returns true if the error indicates that the provided object is missing a 'Kind' field.
func IsMissingVersion ¶ added in v0.12.0
IsMissingVersion returns true if the error indicates that the provided object is missing a 'Versioj' field.
func IsNotRegisteredError ¶ added in v0.7.0
IsNotRegisteredError returns true if the error indicates the provided object or input data is not registered.
func JSONKeyMapper ¶ added in v0.14.0
JSONKeyMapper uses the struct tags on a conversion to determine the key value for the other side. Use when mapping from a map[string]* to a struct or vice versa.
func SetList ¶
SetList sets the given list object's Items member have the elements given in objects. Returns an error if list is not a List type (does not have an Items member), or if any of the objects are not of the right type. TODO: move me to pkg/api/meta
func VerifySwaggerDocsExist ¶ added in v1.1.1
VerifySwaggerDocsExist writes in a io.Writer a list of structs and fields that are missing of documentation.
Types ¶
type Codec ¶
Codec defines methods for serializing and deserializing API objects.
func CodecFor ¶
func CodecFor(codec ObjectCodec, version string) Codec
CodecFor returns a Codec that invokes Encode with the provided version.
func YAMLDecoder ¶ added in v0.14.0
YAMLDecoder adds YAML decoding support to a codec that supports JSON.
type ConversionGenerator ¶ added in v0.18.2
type ConversionGenerator interface { GenerateConversionsForType(version string, reflection reflect.Type) error WriteConversionFunctions(w io.Writer) error RegisterConversionFunctions(w io.Writer, pkg string) error AddImport(pkg string) string RepackImports(exclude sets.String) WriteImports(w io.Writer) error OverwritePackage(pkg, overwrite string) AssumePrivateConversions() }
func NewConversionGenerator ¶ added in v0.18.2
func NewConversionGenerator(scheme *conversion.Scheme, targetPkg string) ConversionGenerator
type Decoder ¶
type Decoder interface { Decode(data []byte) (Object, error) DecodeToVersion(data []byte, version string) (Object, error) DecodeInto(data []byte, obj Object) error DecodeIntoWithSpecifiedVersionKind(data []byte, obj Object, kind, version string) error }
Decoder defines methods for deserializing API objects into a given type
type DeepCopyGenerator ¶ added in v0.18.2
type DeepCopyGenerator interface { // Adds a type to a generator. // If the type is non-struct, it will return an error, otherwise deep-copy // functions for this type and all nested types will be generated. AddType(inType reflect.Type) error // ReplaceType registers a type that should be used instead of the type // with the provided pkgPath and name. ReplaceType(pkgPath, name string, in interface{}) // AddImport registers a package name with the generator and returns its // short name. AddImport(pkgPath string) string // RepackImports creates a stable ordering of import short names RepackImports() // Writes all imports that are necessary for deep-copy function and // their registration. WriteImports(w io.Writer) error // Writes deel-copy functions for all types added via AddType() method // and their nested types. WriteDeepCopyFunctions(w io.Writer) error // Writes an init() function that registers all the generated deep-copy // functions. RegisterDeepCopyFunctions(w io.Writer, pkg string) error // When generating code, all references to "pkg" package name will be // replaced with "overwrite". It is used mainly to replace references // to name of the package in which the code will be created with empty // string. OverwritePackage(pkg, overwrite string) }
TODO(wojtek-t): As suggested in #8320, we should consider the strategy to first do the shallow copy and then recurse into things that need a deep copy (maps, pointers, slices). That sort of copy function would need one parameter - a pointer to the thing it's supposed to expand, and it would involve a lot less memory copying.
func NewDeepCopyGenerator ¶ added in v0.18.2
func NewDeepCopyGenerator(scheme *conversion.Scheme, targetPkg string, include sets.String) DeepCopyGenerator
type EmbeddedObject ¶
type EmbeddedObject struct {
Object
}
EmbeddedObject has appropriate encoder and decoder functions, such that on the wire, it's stored as a []byte, but in memory, the contained object is accessible as an Object via the Get() function. Only valid API objects may be stored via EmbeddedObject. The purpose of this is to allow an API object of type known only at runtime to be embedded within other API objects.
Note that object assumes that you've registered all of your api types with the api package.
EmbeddedObject and RawExtension can be used together to allow for API object extensions: see the comment for RawExtension.
type Encoder ¶
type Encoder interface { Encode(obj Object) (data []byte, err error) EncodeToStream(obj Object, stream io.Writer) error }
Encoder defines methods for serializing API objects into bytes
type FieldLabelConversionFunc ¶ added in v0.12.0
type FieldLabelConversionFunc func(label, value string) (internalLabel, internalValue string, err error)
Function to convert a field selector to internal representation.
type KubeTypes ¶ added in v1.1.1
type KubeTypes []Pair
KubeTypes is an array to represent all available types in a parsed file. [0] is for the type itself
func ParseDocumentationFrom ¶ added in v1.1.1
ParseDocumentationFrom gets all types' documentation and returns them as an array. Each type is again represented as an array (we have to use arrays as we need to be sure for the order of the fields). This function returns fields and struct definitions that have no documentation as {name, ""}.
type MultiObjectTyper ¶ added in v0.16.0
type MultiObjectTyper []ObjectTyper
MultiObjectTyper returns the types of objects across multiple schemes in order.
func (MultiObjectTyper) DataVersionAndKind ¶ added in v0.16.0
func (m MultiObjectTyper) DataVersionAndKind(data []byte) (version, kind string, err error)
func (MultiObjectTyper) ObjectVersionAndKind ¶ added in v0.16.0
func (m MultiObjectTyper) ObjectVersionAndKind(obj Object) (version, kind string, err error)
func (MultiObjectTyper) Recognizes ¶ added in v0.17.0
func (m MultiObjectTyper) Recognizes(version, kind string) bool
type Object ¶
type Object interface { // This function is used only to enforce membership. It's never called. // TODO: Consider mass rename in the future to make it do something useful. IsAnAPIObject() }
All api types must support the Object interface. It's deliberately tiny so that this is not an onerous burden. Implement it with a pointer receiver; this will allow us to use the go compiler to check the one thing about our objects that it's capable of checking for us.
func ExtractList ¶
ExtractList returns obj's Items element as an array of runtime.Objects. Returns an error if obj is not a List type (does not have an Items member). TODO: move me to pkg/api/meta
type ObjectCodec ¶ added in v0.17.0
type ObjectCodec interface { ObjectEncoder Decoder }
ObjectCodec represents the common mechanisms for converting to and from a particular binary representation of an object.
type ObjectConvertor ¶ added in v0.5.1
type ObjectConvertor interface { Convert(in, out interface{}) error ConvertToVersion(in Object, outVersion string) (out Object, err error) ConvertFieldLabel(version, kind, label, value string) (string, string, error) }
ObjectConvertor converts an object to a different version.
type ObjectCopier ¶ added in v0.17.0
type ObjectCopier interface { // Copy returns an exact copy of the provided Object, or an error if the // copy could not be completed. Copy(Object) (Object, error) }
ObjectCopier duplicates an object.
type ObjectCreater ¶ added in v0.13.0
ObjectCreater contains methods for instantiating an object by kind and version.
type ObjectDecoder ¶ added in v0.17.0
type ObjectDecoder interface { Decoder // DataVersionAndKind returns the version and kind of the provided data, or an error // if another problem is detected. In many cases this method can be as expensive to // invoke as the Decode method. DataVersionAndKind([]byte) (version, kind string, err error) // Recognizes returns true if the scheme is able to handle the provided version and kind // of an object. Recognizes(version, kind string) bool }
ObjectDecoder is a convenience interface for identifying serialized versions of objects and transforming them into Objects. It intentionally overlaps with ObjectTyper and Decoder for use in decode only paths.
var UnstructuredJSONScheme ObjectDecoder = unstructuredJSONScheme{}
UnstructuredJSONScheme is capable of converting JSON data into the Unstructured type, which can be used for generic access to objects without a predefined scheme.
type ObjectEncoder ¶ added in v0.17.0
type ObjectEncoder interface { // EncodeToVersion convert and serializes an object in the internal format // to a specified output version. An error is returned if the object // cannot be converted for any reason. EncodeToVersion(obj Object, outVersion string) ([]byte, error) EncodeToVersionStream(obj Object, outVersion string, stream io.Writer) error }
ObjectEncoder turns an object into a byte array. This interface is a general form of the Encoder interface
type ObjectScheme ¶ added in v0.17.0
type ObjectScheme interface { ObjectConvertor ObjectTyper ObjectCreater ObjectCopier }
ObjectScheme represents common conversions between formal external API versions and the internal Go structs. ObjectScheme is typically used with ObjectCodec to transform internal Go structs into serialized versions. There may be many valid ObjectCodecs for each ObjectScheme.
type ObjectTyper ¶ added in v0.5.1
type ObjectTyper interface { // DataVersionAndKind returns the version and kind of the provided data, or an error // if another problem is detected. In many cases this method can be as expensive to // invoke as the Decode method. DataVersionAndKind([]byte) (version, kind string, err error) // ObjectVersionAndKind returns the version and kind of the provided object, or an // error if the object is not recognized (IsNotRegisteredError will return true). ObjectVersionAndKind(Object) (version, kind string, err error) // Recognizes returns true if the scheme is able to handle the provided version and kind, // or more precisely that the provided version is a possible conversion or decoding // target. Recognizes(version, kind string) bool }
ObjectTyper contains methods for extracting the APIVersion and Kind of objects.
type Pair ¶ added in v1.1.1
type Pair struct {
Name, Doc string
}
Pair of strings. We keed the name of fields and the doc
type PluginBase ¶
type PluginBase struct {
Kind string `json:"kind,omitempty"`
}
PluginBase is like TypeMeta, but it's intended for plugin objects that won't ever be encoded except while embedded in other objects.
type RawExtension ¶
type RawExtension struct {
RawJSON []byte
}
RawExtension is used with EmbeddedObject to do a two-phase encoding of extension objects.
To use this, make a field which has RawExtension as its type in your external, versioned struct, and EmbeddedObject in your internal struct. You also need to register your various plugin types.
// Internal package:
type MyAPIObject struct { runtime.TypeMeta `json:",inline"` MyPlugin runtime.EmbeddedObject `json:"myPlugin"` }
type PluginA struct { runtime.PluginBase `json:",inline"` AOption string `json:"aOption"` }
// External package:
type MyAPIObject struct { runtime.TypeMeta `json:",inline"` MyPlugin runtime.RawExtension `json:"myPlugin"` }
type PluginA struct { runtime.PluginBase `json:",inline"` AOption string `json:"aOption"` }
// On the wire, the JSON will look something like this:
{ "kind":"MyAPIObject", "apiVersion":"v1beta1", "myPlugin": { "kind":"PluginA", "aOption":"foo", }, }
So what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the EmbeddedObject. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.)
func (RawExtension) MarshalJSON ¶
func (re RawExtension) MarshalJSON() ([]byte, error)
Marshal may get called on pointers or values, so implement MarshalJSON on value. http://stackoverflow.com/questions/21390979/custom-marshaljson-never-gets-called-in-go
func (*RawExtension) UnmarshalJSON ¶
func (re *RawExtension) UnmarshalJSON(in []byte) error
type ResourceVersioner ¶
type ResourceVersioner interface { SetResourceVersion(obj Object, version string) error ResourceVersion(obj Object) (string, error) }
ResourceVersioner provides methods for setting and retrieving the resource version from an API object.
type Scheme ¶
type Scheme struct {
// contains filtered or unexported fields
}
Scheme defines methods for serializing and deserializing API objects. It is an adaptation of conversion's Scheme for our API objects.
func NewScheme ¶
func NewScheme() *Scheme
NewScheme creates a new Scheme. This scheme is pluggable by default.
func (*Scheme) AddConversionFuncs ¶
AddConversionFuncs adds a function to the list of conversion functions. The given function should know how to convert between two API objects. We deduce how to call it from the types of its two parameters; see the comment for Converter.RegisterConversionFunction.
Note that, if you need to copy sub-objects that didn't change, it's safe to call Convert() inside your conversionFuncs, as long as you don't start a conversion chain that's infinitely recursive.
Also note that the default behavior, if you don't add a conversion function, is to sanely copy fields that have the same names. It's OK if the destination type has extra fields, but it must not remove any. So you only need to add a conversion function for things with changed/removed fields.
func (*Scheme) AddDeepCopyFuncs ¶ added in v0.18.2
AddDeepCopyFuncs adds a function to the list of deep-copy functions. For the expected format of deep-copy function, see the comment for Copier.RegisterDeepCopyFunction.
func (*Scheme) AddDefaultingFuncs ¶ added in v0.11.0
AddDefaultingFuncs adds a function to the list of value-defaulting functions. We deduce how to call it from the types of its two parameters; see the comment for Converter.RegisterDefaultingFunction.
func (*Scheme) AddFieldLabelConversionFunc ¶ added in v0.12.0
func (s *Scheme) AddFieldLabelConversionFunc(version, kind string, conversionFunc FieldLabelConversionFunc) error
AddFieldLabelConversionFunc adds a conversion function to convert field selectors of the given kind from the given version to internal version representation.
func (*Scheme) AddGeneratedConversionFuncs ¶ added in v0.16.0
Similar to AddConversionFuncs, but registers conversion functions that were automatically generated.
func (*Scheme) AddGeneratedDeepCopyFuncs ¶ added in v0.18.2
Similar to AddDeepCopyFuncs, but registers deep-copy functions that were automatically generated.
func (*Scheme) AddKnownTypeWithName ¶
AddKnownTypeWithName is like AddKnownTypes, but it lets you specify what this type should be encoded as. Useful for testing when you don't want to make multiple packages to define your structs.
func (*Scheme) AddKnownTypes ¶
AddKnownTypes registers the types of the arguments to the marshaller of the package api. Encode() refuses the object unless its type is registered with AddKnownTypes.
func (*Scheme) AddStructFieldConversion ¶ added in v0.6.0
func (s *Scheme) AddStructFieldConversion(srcFieldType interface{}, srcFieldName string, destFieldType interface{}, destFieldName string) error
AddStructFieldConversion allows you to specify a mechanical copy for a moved or renamed struct field without writing an entire conversion function. See the comment in conversion.Converter.SetStructFieldCopy for parameter details. Call as many times as needed, even on the same fields.
func (*Scheme) Convert ¶
Convert will attempt to convert in into out. Both must be pointers. For easy testing of conversion functions. Returns an error if the conversion isn't possible.
func (*Scheme) ConvertFieldLabel ¶ added in v0.12.0
Converts the given field label and value for an kind field selector from versioned representation to an unversioned one.
func (*Scheme) ConvertToVersion ¶ added in v0.5.1
ConvertToVersion attempts to convert an input object to its matching Kind in another version within this scheme. Will return an error if the provided version does not contain the inKind (or a mapping by name defined with AddKnownTypeWithName). Will also return an error if the conversion does not result in a valid Object being returned.
func (*Scheme) DataVersionAndKind ¶ added in v0.5.1
DataVersionAndKind will return the APIVersion and Kind of the given wire-format encoding of an API Object, or an error.
func (*Scheme) Decode ¶
Decode converts a YAML or JSON string back into a pointer to an api object. Deduces the type based upon the APIVersion and Kind fields, which are set by Encode. Only versioned objects (APIVersion != "") are accepted. The object will be converted into the in-memory unversioned type before being returned.
func (*Scheme) DecodeInto ¶
DecodeInto parses a YAML or JSON string and stores it in obj. Returns an error if data.Kind is set and doesn't match the type of obj. Obj should be a pointer to an api type. If obj's APIVersion doesn't match that in data, an attempt will be made to convert data into obj's version. TODO: allow Decode/DecodeInto to take a default apiVersion and a default kind, to be applied if the provided object does not have either field (integrate external apis into the decoding scheme).
func (*Scheme) DecodeIntoWithSpecifiedVersionKind ¶ added in v1.1.1
func (*Scheme) DecodeToVersion ¶ added in v1.1.1
DecodeToVersion converts a YAML or JSON string back into a pointer to an api object. Deduces the type based upon the APIVersion and Kind fields, which are set by Encode. Only versioned objects (APIVersion != "") are accepted. The object will be converted into the in-memory versioned type requested before being returned.
func (*Scheme) EncodeToVersion ¶
EncodeToVersion turns the given api object into an appropriate JSON string. Will return an error if the object doesn't have an embedded TypeMeta. Obj may be a pointer to a struct, or a struct. If a struct, a copy must be made. If a pointer, the object may be modified before encoding, but will be put back into its original state before returning.
Memory/wire format differences:
- Having to keep track of the Kind and APIVersion fields makes tests very annoying, so the rule is that they are set only in wire format (json), not when in native (memory) format. This is possible because both pieces of information are implicit in the go typed object.
- An exception: note that, if there are embedded API objects of known type, for example, PodList{... Items []Pod ...}, these embedded objects must be of the same version of the object they are embedded within, and their APIVersion and Kind must both be empty.
- Note that the exception does not apply to the APIObject type, which recursively does Encode()/Decode(), and is capable of expressing any API object.
- Only versioned objects should be encoded. This means that, if you pass a native object, Encode will convert it to a versioned object. For example, an api.Pod will get converted to a v1beta1.Pod. However, if you pass in an object that's already versioned (v1beta1.Pod), Encode will not modify it.
The purpose of the above complex conversion behavior is to allow us to change the memory format yet not break compatibility with any stored objects, whether they be in our storage layer (e.g., etcd), or in user's config files.
func (*Scheme) EncodeToVersionStream ¶ added in v1.1.1
func (*Scheme) KnownTypes ¶
KnownTypes returns the types known for the given version. Return value must be treated as read-only.
func (*Scheme) Log ¶
func (s *Scheme) Log(l conversion.DebugLogger)
Log sets a logger on the scheme. For test purposes only
func (*Scheme) New ¶
New returns a new API object of the given version ("" for internal representation) and name, or an error if it hasn't been registered.
func (*Scheme) ObjectVersionAndKind ¶
ObjectVersionAndKind returns the version and kind of the given Object.
func (*Scheme) Raw ¶ added in v0.16.0
func (self *Scheme) Raw() *conversion.Scheme
func (*Scheme) Recognizes ¶ added in v0.17.0
Recognizes returns true if the scheme is able to handle the provided version and kind of an object.
type SelfLinker ¶
type SelfLinker interface { SetSelfLink(obj Object, selfLink string) error SelfLink(obj Object) (string, error) // Knowing Name is sometimes necessary to use a SelfLinker. Name(obj Object) (string, error) // Knowing Namespace is sometimes necessary to use a SelfLinker Namespace(obj Object) (string, error) }
SelfLinker provides methods for setting and retrieving the SelfLink field of an API object.
type TypeMeta ¶
type TypeMeta struct { APIVersion string `json:"apiVersion,omitempty" yaml:"apiVersion,omitempty"` Kind string `json:"kind,omitempty" yaml:"kind,omitempty"` }
TypeMeta is shared by all top level objects. The proper way to use it is to inline it in your type, like this:
type MyAwesomeAPIObject struct { runtime.TypeMeta `json:",inline"` ... // other fields }
func (*MyAwesomeAPIObject) IsAnAPIObject() {}
TypeMeta is provided here for convenience. You may use it directly from this package or define your own with the same fields.
type Unknown ¶
type Unknown struct { TypeMeta `json:",inline"` // RawJSON will hold the complete JSON of the object which couldn't be matched // with a registered type. Most likely, nothing should be done with this // except for passing it through the system. RawJSON []byte }
Unknown allows api objects with unknown types to be passed-through. This can be used to deal with the API objects from a plug-in. Unknown objects still have functioning TypeMeta features-- kind, version, etc. TODO: Make this object have easy access to field based accessors and settors for metadata and field mutatation.
func (*Unknown) IsAnAPIObject ¶
func (*Unknown) IsAnAPIObject()
type Unstructured ¶ added in v0.17.0
type Unstructured struct { TypeMeta `json:",inline"` // Object is a JSON compatible map with string, float, int, []interface{}, or map[string]interface{} // children. Object map[string]interface{} }
Unstructured allows objects that do not have Golang structs registered to be manipulated generically. This can be used to deal with the API objects from a plug-in. Unstructured objects still have functioning TypeMeta features-- kind, version, etc. TODO: Make this object have easy access to field based accessors and settors for metadata and field mutatation.
func (*Unstructured) IsAnAPIObject ¶ added in v0.17.0
func (*Unstructured) IsAnAPIObject()