This repository has been archived by the owner on Mar 22, 2018. It is now read-only.
-
Notifications
You must be signed in to change notification settings - Fork 19
/
main.go
148 lines (131 loc) · 3.81 KB
/
main.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
// origin-version-change is a simple utility for converting a
// storage object into a different api version.
package main
import (
"bytes"
"encoding/json"
"io"
"io/ioutil"
"log"
"os"
"runtime"
"github.com/ghodss/yaml"
"github.com/golang/glog"
flag "github.com/spf13/pflag"
"github.com/GoogleCloudPlatform/kubernetes/pkg/api"
_ "github.com/GoogleCloudPlatform/kubernetes/pkg/api/latest"
"github.com/GoogleCloudPlatform/kubernetes/pkg/kubectl/resource"
kruntime "github.com/GoogleCloudPlatform/kubernetes/pkg/runtime"
"github.com/GoogleCloudPlatform/kubernetes/pkg/util"
"github.com/openshift/origin/pkg/api/latest"
templateapi "github.com/openshift/origin/pkg/template/api"
)
var (
inputSource = flag.StringP("input", "i", "-", "Input source; '-' means stdin")
outputDest = flag.StringP("output", "o", "-", "Output destination; '-' means stdout")
rewrite = flag.StringP("rewrite", "r", "", "If nonempty, use this as both input and output.")
outputVersion = flag.StringP("out-version", "v", latest.Version, "Version to convert input to")
)
// isYAML determines whether data is JSON or YAML formatted by seeing
// if it will parse as json.
func isYAML(data []byte) bool {
var unused interface{}
if err := json.Unmarshal(data, &unused); err != nil {
return true
}
return false
}
func changeTemplateObjectsVersion(t *templateapi.Template) {
if errs := kruntime.DecodeList(t.Objects, api.Scheme); len(errs) > 0 {
log.Fatalf("Unable to decode Template objects: %v", errs)
}
for i, obj := range t.Objects {
_, kind, err := api.Scheme.ObjectVersionAndKind(obj)
if err != nil {
glog.Infof("Template.Objects[%d]: Unable to determine version and kind: %v", i, err)
continue
}
mapping, err := latest.RESTMapper.RESTMapping(kind, *outputVersion)
if err != nil {
glog.Infof("Template.Objects[%d]: Unable to get REST mappings: %v", err)
continue
}
info := resource.Info{Object: obj, Mapping: mapping}
outputObj, err := resource.AsVersionedObject([]*resource.Info{&info}, false, *outputVersion)
if err != nil {
glog.Infof("Template.Objects[%d]: Unable to convert: %v", err)
continue
}
t.Objects[i] = outputObj
}
}
func main() {
runtime.GOMAXPROCS(runtime.NumCPU())
flag.CommandLine.SetNormalizeFunc(util.WordSepNormalizeFunc)
flag.Parse()
if *rewrite != "" {
*inputSource = *rewrite
*outputDest = *rewrite
}
var in io.Reader
if *inputSource == "-" {
in = os.Stdin
} else {
f, err := os.Open(*inputSource)
if err != nil {
log.Fatalf("Couldn't open %q: %q", *inputSource, err)
}
defer f.Close()
in = f
}
data, err := ioutil.ReadAll(in)
if err != nil {
log.Fatalf("Couldn't read from input: %q", err)
}
isYAML := isYAML(data)
if isYAML {
data, err = yaml.YAMLToJSON(data)
if err != nil {
log.Fatalf("Failed to convert YAML to JSON: %q", err)
}
}
obj, err := api.Scheme.Decode(data)
if err != nil {
log.Fatalf("Couldn't decode input: %q", err)
}
if template, ok := obj.(*templateapi.Template); ok {
changeTemplateObjectsVersion(template)
}
outData, err := api.Scheme.EncodeToVersion(obj, *outputVersion)
if err != nil {
log.Fatalf("Failed to encode to version %q: %q", *outputVersion, err)
}
if isYAML {
outData, err = yaml.JSONToYAML(outData)
if err != nil {
log.Fatalf("Failed to convert to YAML: %q", err)
}
} else if true {
// TODO: figure out if input JSON was pretty.
var buf bytes.Buffer
err = json.Indent(&buf, outData, "", " ")
if err != nil {
log.Fatalf("Failed to indent JSON: %q", err)
}
outData = buf.Bytes()
}
var out io.Writer
if *outputDest == "-" {
out = os.Stdout
} else {
f, err := os.Create(*outputDest)
if err != nil {
log.Fatalf("Couldn't open %q: %q", *outputDest, err)
}
defer f.Close()
out = f
}
if _, err = out.Write(outData); err != nil {
log.Fatalf("Failed to write: %q", err)
}
}