func generateConversions(t *testing.T, version string) bytes.Buffer {
g := runtime.NewConversionGenerator(api.Scheme.Raw(), path.Join("k8s.io/kubernetes/pkg/api", version))
apiShort := g.AddImport("k8s.io/kubernetes/pkg/api")
g.AddImport("k8s.io/kubernetes/pkg/api/resource")
// TODO(wojtek-t): Change the overwrites to a flag.
g.OverwritePackage(version, "")
for _, knownType := range api.Scheme.KnownTypes(version) {
if err := g.GenerateConversionsForType(version, knownType); err != nil {
t.Fatalf("error while generating conversion functions for %v: %v", knownType, err)
}
}
g.RepackImports(util.NewStringSet())
var functions bytes.Buffer
functionsWriter := bufio.NewWriter(&functions)
if err := g.WriteImports(functionsWriter); err != nil {
t.Fatalf("error while writing imports: %v", err)
}
if err := g.WriteConversionFunctions(functionsWriter); err != nil {
t.Fatalf("couldn't generate conversion functions: %v", err)
}
if err := g.RegisterConversionFunctions(functionsWriter, fmt.Sprintf("%s.Scheme", apiShort)); err != nil {
t.Fatalf("couldn't generate conversion function names: %v", err)
}
if err := functionsWriter.Flush(); err != nil {
t.Fatalf("error while flushing writer")
}
return functions
}
func main() {
runtime.GOMAXPROCS(runtime.NumCPU())
flag.Parse()
var funcOut io.Writer
if *functionDest == "-" {
funcOut = os.Stdout
} else {
file, err := os.Create(*functionDest)
if err != nil {
glog.Fatalf("Couldn't open %v: %v", *functionDest, err)
}
defer file.Close()
funcOut = file
}
data := new(bytes.Buffer)
group, version := path.Split(*groupVersion)
group = strings.TrimRight(group, "/")
_, err := data.WriteString(fmt.Sprintf("package %v\n", version))
if err != nil {
glog.Fatalf("error writing package line: %v", err)
}
versionPath := path.Join(pkgBase, group, version)
generator := pkg_runtime.NewConversionGenerator(api.Scheme.Raw(), versionPath)
apiShort := generator.AddImport(path.Join(pkgBase, "api"))
generator.AddImport(path.Join(pkgBase, "api/resource"))
// TODO(wojtek-t): Change the overwrites to a flag.
generator.OverwritePackage(version, "")
for _, knownType := range api.Scheme.KnownTypes(version) {
if !strings.HasPrefix(knownType.PkgPath(), versionPath) {
continue
}
if err := generator.GenerateConversionsForType(version, knownType); err != nil {
glog.Errorf("error while generating conversion functions for %v: %v", knownType, err)
}
}
generator.RepackImports(util.NewStringSet())
if err := generator.WriteImports(data); err != nil {
glog.Fatalf("error while writing imports: %v", err)
}
if err := generator.WriteConversionFunctions(data); err != nil {
glog.Fatalf("Error while writing conversion functions: %v", err)
}
if err := generator.RegisterConversionFunctions(data, fmt.Sprintf("%s.Scheme", apiShort)); err != nil {
glog.Fatalf("Error while writing conversion functions: %v", err)
}
b, err := imports.Process("", data.Bytes(), nil)
if err != nil {
glog.Fatalf("error while update imports: %v", err)
}
if _, err := funcOut.Write(b); err != nil {
glog.Fatalf("error while writing out the resulting file: %v", err)
}
}
func main() {
runtime.GOMAXPROCS(runtime.NumCPU())
flag.Parse()
log.SetOutput(os.Stderr)
var funcOut io.Writer
if *functionDest == "-" {
funcOut = os.Stdout
} else {
file, err := os.Create(*functionDest)
if err != nil {
glog.Fatalf("Couldn't open %v: %v", *functionDest, err)
}
defer file.Close()
funcOut = file
}
generator := pkg_runtime.NewConversionGenerator(api.Scheme, "github.com/openshift/origin/pkg/api")
apiShort := generator.AddImport("k8s.io/kubernetes/pkg/api")
generator.AddImport("k8s.io/kubernetes/pkg/api/resource")
generator.AssumePrivateConversions()
// TODO(wojtek-t): Change the overwrites to a flag.
generator.OverwritePackage(*version, "")
gv := unversioned.GroupVersion{Group: *group, Version: *version}
knownTypes := api.Scheme.KnownTypes(gv)
knownTypeKeys := []string{}
for key := range knownTypes {
knownTypeKeys = append(knownTypeKeys, key)
}
sort.Strings(knownTypeKeys)
for _, knownTypeKey := range knownTypeKeys {
knownType := knownTypes[knownTypeKey]
if !strings.Contains(knownType.PkgPath(), "openshift/origin") {
continue
}
if err := generator.GenerateConversionsForType(gv, knownType); err != nil {
glog.Errorf("error while generating conversion functions for %v: %v", knownType, err)
}
}
// generator.RepackImports(sets.NewString("k8s.io/kubernetes/pkg/runtime"))
// the repack changes the name of the import
apiShort = generator.AddImport("k8s.io/kubernetes/pkg/api")
if err := generator.WriteImports(funcOut); err != nil {
glog.Fatalf("error while writing imports: %v", err)
}
if err := generator.WriteConversionFunctions(funcOut); err != nil {
glog.Fatalf("Error while writing conversion functions: %v", err)
}
if err := generator.RegisterConversionFunctions(funcOut, fmt.Sprintf("%s.Scheme", apiShort)); err != nil {
glog.Fatalf("Error while writing conversion functions: %v", err)
}
}
func main() {
runtime.GOMAXPROCS(runtime.NumCPU())
flag.Parse()
var funcOut io.Writer
if *functionDest == "-" {
funcOut = os.Stdout
} else {
file, err := os.Create(*functionDest)
if err != nil {
glog.Fatalf("Couldn't open %v: %v", *functionDest, err)
}
defer file.Close()
funcOut = file
}
generator := pkg_runtime.NewConversionGenerator(api.Scheme.Raw(), "github.com/openshift/origin/pkg/api")
apiShort := generator.AddImport("k8s.io/kubernetes/pkg/api")
generator.AddImport("k8s.io/kubernetes/pkg/api/resource")
generator.AssumePrivateConversions()
// TODO(wojtek-t): Change the overwrites to a flag.
generator.OverwritePackage(*version, "")
for _, knownType := range api.Scheme.KnownTypes(*version) {
if !strings.Contains(knownType.PkgPath(), "openshift/origin") {
continue
}
if err := generator.GenerateConversionsForType(*version, knownType); err != nil {
glog.Errorf("error while generating conversion functions for %v: %v", knownType, err)
}
}
generator.RepackImports(util.NewStringSet("k8s.io/kubernetes/pkg/runtime"))
// the repack changes the name of the import
apiShort = generator.AddImport("k8s.io/kubernetes/pkg/api")
if err := generator.WriteImports(funcOut); err != nil {
glog.Fatalf("error while writing imports: %v", err)
}
if err := generator.WriteConversionFunctions(funcOut); err != nil {
glog.Fatalf("Error while writing conversion functions: %v", err)
}
if err := generator.RegisterConversionFunctions(funcOut, fmt.Sprintf("%s.Scheme", apiShort)); err != nil {
glog.Fatalf("Error while writing conversion functions: %v", err)
}
}
func generateConversions(t *testing.T, version string) bytes.Buffer {
g := runtime.NewConversionGenerator(api.Scheme.Raw())
g.OverwritePackage(version, "")
for _, knownType := range api.Scheme.KnownTypes(version) {
if err := g.GenerateConversionsForType(version, knownType); err != nil {
glog.Errorf("error while generating conversion functions for %v: %v", knownType, err)
}
}
var functions bytes.Buffer
functionsWriter := bufio.NewWriter(&functions)
if err := g.WriteConversionFunctions(functionsWriter); err != nil {
t.Fatalf("couldn't generate conversion functions: %v", err)
}
if err := g.RegisterConversionFunctions(functionsWriter); err != nil {
t.Fatalf("couldn't generate conversion function names: %v", err)
}
if err := functionsWriter.Flush(); err != nil {
t.Fatalf("error while flushing writer")
}
return functions
}
func main() {
runtime.GOMAXPROCS(runtime.NumCPU())
flag.Parse()
var funcOut io.Writer
if *functionDest == "-" {
funcOut = os.Stdout
} else {
file, err := os.Create(*functionDest)
if err != nil {
glog.Fatalf("Couldn't open %v: %v", *functionDest, err)
}
defer file.Close()
funcOut = file
}
data := new(bytes.Buffer)
gv, err := unversioned.ParseGroupVersion(*groupVersion)
if err != nil {
glog.Fatalf("Error parsing groupversion %v: %v", *groupVersion, err)
}
_, err = data.WriteString(fmt.Sprintf("package %v\n", gv.Version))
if err != nil {
glog.Fatalf("Error while writing package line: %v", err)
}
versionPath := pkgPath(gv.Group, gv.Version)
generator := kruntime.NewConversionGenerator(api.Scheme, versionPath)
apiShort := generator.AddImport(path.Join(pkgBase, "api"))
generator.AddImport(path.Join(pkgBase, "api/resource"))
generator.AddImport(path.Join(pkgBase, "types"))
// TODO(wojtek-t): Change the overwrites to a flag.
generator.OverwritePackage(gv.Version, "")
for _, knownType := range api.Scheme.KnownTypes(gv) {
if knownType.PkgPath() != versionPath {
continue
}
if err := generator.GenerateConversionsForType(gv, knownType); err != nil {
glog.Errorf("Error while generating conversion functions for %v: %v", knownType, err)
}
}
generator.RepackImports(sets.NewString())
if err := generator.WriteImports(data); err != nil {
glog.Fatalf("Error while writing imports: %v", err)
}
if err := generator.WriteConversionFunctions(data); err != nil {
glog.Fatalf("Error while writing conversion functions: %v", err)
}
if err := generator.RegisterConversionFunctions(data, fmt.Sprintf("%s.Scheme", apiShort)); err != nil {
glog.Fatalf("Error while writing conversion functions: %v", err)
}
b, err := imports.Process("", data.Bytes(), nil)
if err != nil {
for i, s := range bytes.Split(data.Bytes(), []byte("\n")) {
glog.Infof("%d:\t%s", i, s)
}
glog.Fatalf("Error while update imports: %v\n", err)
}
if _, err := funcOut.Write(b); err != nil {
glog.Fatalf("Error while writing out the resulting file: %v", err)
}
}