func newEtcd(ns runtime.NegotiatedSerializer, storageGroupVersionString, memoryGroupVersionString string, etcdConfig etcdstorage.EtcdConfig) (etcdStorage storage.Interface, err error) { if storageGroupVersionString == "" { return etcdStorage, fmt.Errorf("storageVersion is required to create a etcd storage") } storageVersion, err := unversioned.ParseGroupVersion(storageGroupVersionString) if err != nil { return nil, fmt.Errorf("couldn't understand storage version %v: %v", storageGroupVersionString, err) } memoryVersion, err := unversioned.ParseGroupVersion(memoryGroupVersionString) if err != nil { return nil, fmt.Errorf("couldn't understand memory version %v: %v", memoryGroupVersionString, err) } var storageConfig etcdstorage.EtcdStorageConfig storageConfig.Config = etcdConfig s, ok := ns.SerializerForMediaType("application/json", nil) if !ok { return nil, fmt.Errorf("unable to find serializer for JSON") } glog.Infof("constructing etcd storage interface.\n sv: %v\n mv: %v\n", storageVersion, memoryVersion) encoder := ns.EncoderForVersion(s, storageVersion) decoder := ns.DecoderToVersion(s, memoryVersion) if memoryVersion.Group != storageVersion.Group { // Allow this codec to translate between groups. if err = versioning.EnableCrossGroupEncoding(encoder, memoryVersion.Group, storageVersion.Group); err != nil { return nil, fmt.Errorf("error setting up encoder for %v: %v", storageGroupVersionString, err) } if err = versioning.EnableCrossGroupDecoding(decoder, storageVersion.Group, memoryVersion.Group); err != nil { return nil, fmt.Errorf("error setting up decoder for %v: %v", storageGroupVersionString, err) } } storageConfig.Codec = runtime.NewCodec(encoder, decoder) return storageConfig.NewStorage() }
// NewStorageCodec assembles a storage codec for the provided storage media type, the provided serializer, and the requested // storage and memory versions. func NewStorageCodec(storageMediaType string, ns runtime.StorageSerializer, storageVersion, memoryVersion unversioned.GroupVersion, config storagebackend.Config) (runtime.Codec, error) { mediaType, options, err := mime.ParseMediaType(storageMediaType) if err != nil { return nil, fmt.Errorf("%q is not a valid mime-type", storageMediaType) } serializer, ok := ns.SerializerForMediaType(mediaType, options) if !ok { return nil, fmt.Errorf("unable to find serializer for %q", storageMediaType) } s := serializer.Serializer // etcd2 only supports string data - we must wrap any result before returning // TODO: storagebackend should return a boolean indicating whether it supports binary data if !serializer.EncodesAsText && (config.Type == storagebackend.StorageTypeUnset || config.Type == storagebackend.StorageTypeETCD2) { glog.V(4).Infof("Wrapping the underlying binary storage serializer with a base64 encoding for etcd2") s = runtime.NewBase64Serializer(s) } ds := recognizer.NewDecoder(s, ns.UniversalDeserializer()) encoder := ns.EncoderForVersion(s, storageVersion) decoder := ns.DecoderToVersion(ds, memoryVersion) if memoryVersion.Group != storageVersion.Group { // Allow this codec to translate between groups. if err := versioning.EnableCrossGroupEncoding(encoder, memoryVersion.Group, storageVersion.Group); err != nil { return nil, fmt.Errorf("error setting up encoder from %v to %v: %v", memoryVersion, storageVersion, err) } if err := versioning.EnableCrossGroupDecoding(decoder, storageVersion.Group, memoryVersion.Group); err != nil { return nil, fmt.Errorf("error setting up decoder from %v to %v: %v", storageVersion, memoryVersion, err) } } return runtime.NewCodec(encoder, decoder), nil }
func newEtcd(ns runtime.NegotiatedSerializer, storageVersion, memoryVersion unversioned.GroupVersion, config storagebackend.Config) (etcdStorage storage.Interface, err error) { s, ok := ns.SerializerForMediaType("application/json", nil) if !ok { return nil, fmt.Errorf("unable to find serializer for JSON") } encoder := ns.EncoderForVersion(s, storageVersion) decoder := ns.DecoderToVersion(s, memoryVersion) if memoryVersion.Group != storageVersion.Group { // Allow this codec to translate between groups. if err = versioning.EnableCrossGroupEncoding(encoder, memoryVersion.Group, storageVersion.Group); err != nil { return nil, fmt.Errorf("error setting up encoder from %v to %v: %v", memoryVersion, storageVersion, err) } if err = versioning.EnableCrossGroupDecoding(decoder, storageVersion.Group, memoryVersion.Group); err != nil { return nil, fmt.Errorf("error setting up decoder from %v to %v: %v", storageVersion, memoryVersion, err) } } config.Codec = runtime.NewCodec(encoder, decoder) return storagebackend.Create(config) }
func TestSetControllerConversion(t *testing.T) { if err := api.Scheme.AddConversionFuncs(Convert_v1beta1_ReplicaSet_to_api_ReplicationController); err != nil { t.Fatal(err) } rs := &extensions.ReplicaSet{} rc := &api.ReplicationController{} extGroup := testapi.Extensions defaultGroup := testapi.Default fuzzInternalObject(t, extGroup.InternalGroupVersion(), rs, rand.Int63()) t.Logf("rs._internal.extensions -> rs.v1beta1.extensions") data, err := runtime.Encode(extGroup.Codec(), rs) if err != nil { t.Fatalf("unexpected encoding error: %v", err) } decoder := api.Codecs.UniversalDecoder(*extGroup.GroupVersion(), *defaultGroup.GroupVersion()) if err := versioning.EnableCrossGroupDecoding(decoder, extGroup.GroupVersion().Group, defaultGroup.GroupVersion().Group); err != nil { t.Fatalf("unexpected error while enabling cross-group decoding: %v", err) } t.Logf("rs.v1beta1.extensions -> rc._internal") if err := runtime.DecodeInto(decoder, data, rc); err != nil { t.Fatalf("unexpected decoding error: %v", err) } t.Logf("rc._internal -> rc.v1") data, err = runtime.Encode(defaultGroup.Codec(), rc) if err != nil { t.Fatalf("unexpected encoding error: %v", err) } t.Logf("rc.v1 -> rs._internal.extensions") if err := runtime.DecodeInto(decoder, data, rs); err != nil { t.Fatalf("unexpected decoding error: %v", err) } }