func (t *thirdPartyResourceDataEncoder) Encode(obj runtime.Object, stream io.Writer) (err error) { switch obj := obj.(type) { case *extensions.ThirdPartyResourceData: return encodeToJSON(obj, stream) case *extensions.ThirdPartyResourceDataList: // TODO: There are likely still better ways to do this... listItems := make([]json.RawMessage, len(obj.Items)) for ix := range obj.Items { buff := &bytes.Buffer{} err := encodeToJSON(&obj.Items[ix], buff) if err != nil { return err } listItems[ix] = json.RawMessage(buff.Bytes()) } if t.gvk.Empty() { return fmt.Errorf("thirdPartyResourceDataEncoder was not given a target version") } encMap := struct { // +optional Kind string `json:"kind,omitempty"` Items []json.RawMessage `json:"items"` // +optional Metadata metav1.ListMeta `json:"metadata,omitempty"` // +optional APIVersion string `json:"apiVersion,omitempty"` }{ Kind: t.gvk.Kind + "List", Items: listItems, Metadata: obj.ListMeta, APIVersion: t.gvk.GroupVersion().String(), } encBytes, err := json.Marshal(encMap) if err != nil { return err } _, err = stream.Write(encBytes) return err case *metav1.InternalEvent: event := &metav1.WatchEvent{} err := metav1.Convert_versioned_InternalEvent_to_versioned_Event(obj, event, nil) if err != nil { return err } enc := json.NewEncoder(stream) err = enc.Encode(event) if err != nil { return err } return nil case *metav1.Status, *metav1.APIResourceList: return t.delegate.Encode(obj, stream) default: return fmt.Errorf("unexpected object to encode: %#v", obj) } }
// This is a "fast-path" that avoids reflection for common types. It focuses on the objects that are // converted the most in the cluster. // TODO: generate one of these for every external API group - this is to prove the impact func addFastPathConversionFuncs(scheme *runtime.Scheme) error { scheme.AddGenericConversionFunc(func(objA, objB interface{}, s conversion.Scope) (bool, error) { switch a := objA.(type) { case *Pod: switch b := objB.(type) { case *api.Pod: return true, Convert_v1_Pod_To_api_Pod(a, b, s) } case *api.Pod: switch b := objB.(type) { case *Pod: return true, Convert_api_Pod_To_v1_Pod(a, b, s) } case *Event: switch b := objB.(type) { case *api.Event: return true, Convert_v1_Event_To_api_Event(a, b, s) } case *api.Event: switch b := objB.(type) { case *Event: return true, Convert_api_Event_To_v1_Event(a, b, s) } case *ReplicationController: switch b := objB.(type) { case *api.ReplicationController: return true, Convert_v1_ReplicationController_To_api_ReplicationController(a, b, s) } case *api.ReplicationController: switch b := objB.(type) { case *ReplicationController: return true, Convert_api_ReplicationController_To_v1_ReplicationController(a, b, s) } case *Node: switch b := objB.(type) { case *api.Node: return true, Convert_v1_Node_To_api_Node(a, b, s) } case *api.Node: switch b := objB.(type) { case *Node: return true, Convert_api_Node_To_v1_Node(a, b, s) } case *Namespace: switch b := objB.(type) { case *api.Namespace: return true, Convert_v1_Namespace_To_api_Namespace(a, b, s) } case *api.Namespace: switch b := objB.(type) { case *Namespace: return true, Convert_api_Namespace_To_v1_Namespace(a, b, s) } case *Service: switch b := objB.(type) { case *api.Service: return true, Convert_v1_Service_To_api_Service(a, b, s) } case *api.Service: switch b := objB.(type) { case *Service: return true, Convert_api_Service_To_v1_Service(a, b, s) } case *Endpoints: switch b := objB.(type) { case *api.Endpoints: return true, Convert_v1_Endpoints_To_api_Endpoints(a, b, s) } case *api.Endpoints: switch b := objB.(type) { case *Endpoints: return true, Convert_api_Endpoints_To_v1_Endpoints(a, b, s) } case *metav1.WatchEvent: switch b := objB.(type) { case *metav1.InternalEvent: return true, metav1.Convert_versioned_Event_to_versioned_InternalEvent(a, b, s) } case *metav1.InternalEvent: switch b := objB.(type) { case *metav1.WatchEvent: return true, metav1.Convert_versioned_InternalEvent_to_versioned_Event(a, b, s) } } return false, nil }) return nil }