Skip to content

Commit

Permalink
Output List kind object when using stdout
Browse files Browse the repository at this point in the history 
Now user gets a `List` kind object when putting eveything on
stdout or in a single file.

Fixes kubernetes#73
  • Loading branch information
@surajssd
surajssd committed Aug 9, 2016
1 parent aaa94d7 commit 6fe9755
Showing 1 changed file with 90 additions and 89 deletions.
179 changes: 90 additions & 89 deletions cli/app/app.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -909,25 +909,28 @@ type convertOptions struct {

// Convert komposeObject to K8S controllers
func komposeConvert(komposeObject KomposeObject, opt convertOptions) {
mServices := make(map[string][]byte)
mReplicationControllers := make(map[string][]byte)
mDeployments := make(map[string][]byte)
mDaemonSets := make(map[string][]byte)
// OpenShift DeploymentConfigs
mDeploymentConfigs := make(map[string][]byte)

f := createOutFile(opt.outFile)
defer f.Close()

var svcnames []string

// this will hold all the converted data, it is of elements are of type
// []runtime.Object because for each input service we can have kubernetes/
// openshift controller and possibly a service
objects := make(map[string][]runtime.Object)
for name, service := range komposeObject.ServiceConfigs {
svcnames = append(svcnames, name)
rc := initRC(name, service, opt.replicas)
sc := initSC(name, service)
dc := initDC(name, service, opt.replicas)
ds := initDS(name, service)
osDC := initDeploymentConfig(name, service, opt.replicas) // OpenShift DeploymentConfigs

var controller runtime.Object
// only one controller will be created per service so using switch
switch {
case opt.createD:
controller = initDC(name, service, opt.replicas)
case opt.createDS:
controller = initDS(name, service)
case opt.createRC:
controller = initRC(name, service, opt.replicas)
case opt.createDeploymentConfig:
controller = initDeploymentConfig(name, service, opt.replicas) // OpenShift DeploymentConfigs
}

// Configure the environment variables.
envs := configEnvs(name, service)
Expand Down Expand Up @@ -991,97 +994,95 @@ func komposeConvert(komposeObject KomposeObject, opt convertOptions) {
meta.Annotations = annotations
}

// Update each supported controllers
updateController(rc, fillTemplate, fillObjectMeta)
updateController(dc, fillTemplate, fillObjectMeta)
updateController(ds, fillTemplate, fillObjectMeta)
// OpenShift DeploymentConfigs
updateController(osDC, fillTemplate, fillObjectMeta)
// update supported controller
updateController(controller, fillTemplate, fillObjectMeta)

// convert datarc to json / yaml
datarc, err := transformer(rc, opt.generateYaml)
if err != nil {
logrus.Fatalf(err.Error())
}

// convert datadc to json / yaml
datadc, err := transformer(dc, opt.generateYaml)
if err != nil {
logrus.Fatalf(err.Error())
}
// add service to the list of objects
objects[name] = append(objects[name], controller)

// convert datads to json / yaml
datads, err := transformer(ds, opt.generateYaml)
if err != nil {
logrus.Fatalf(err.Error())
}

var datasvc []byte
// If ports not provided in configuration we will not make service
if len(ports) == 0 {
logrus.Warningf("[%s] Service cannot be created because of missing port.", name)
} else if len(ports) != 0 {
// convert datasvc to json / yaml
datasvc, err = transformer(sc, opt.generateYaml)
if err != nil {
logrus.Fatalf(err.Error())
}
} else {
objects[name] = append(objects[name], sc)
}
}
PrintList(objects, opt)
}

// convert OpenShift DeploymentConfig to json / yaml
dataDeploymentConfig, err := transformer(osDC, opt.generateYaml)
if err != nil {
logrus.Fatalf(err.Error())
}
func PrintList(objects map[string][]runtime.Object, opt convertOptions) error {
f := createOutFile(opt.outFile)
defer f.Close()

mServices[name] = datasvc
mReplicationControllers[name] = datarc
mDeployments[name] = datadc
mDaemonSets[name] = datads
mDeploymentConfigs[name] = dataDeploymentConfig
}
var err error

for k, v := range mServices {
if v != nil {
print(k, "svc", v, opt.toStdout, opt.generateYaml, f)
}
}
// if asked to print to stdout or to put in single file
// we will create a list
if opt.toStdout || f != nil {
list := &api.List{}

// If --out or --stdout is set, the validation should already prevent multiple controllers being generated
if opt.createD {
for k, v := range mDeployments {
print(k, "deployment", v, opt.toStdout, opt.generateYaml, f)
for _, v := range objects {
list.Items = append(list.Items, v...)
}
}

if opt.createDS {
for k, v := range mDaemonSets {
print(k, "daemonset", v, opt.toStdout, opt.generateYaml, f)
// version each object in the list
list.Items, err = ConvertToVersion(list.Items)
if err != nil {
return err
}
}

if opt.createRC {
for k, v := range mReplicationControllers {
print(k, "rc", v, opt.toStdout, opt.generateYaml, f)
// version list itself
listVersion := unversioned.GroupVersion{Group: "", Version: "v1"}
convertedList, err := api.Scheme.ConvertToVersion(list, listVersion)
if err != nil {
return err
}
data, err := marshal(convertedList, opt.generateYaml)
print("", "", data, opt.toStdout, opt.generateYaml, f)
} else {
for k, vals := range objects {
vals, err = ConvertToVersion(vals)
if err != nil {
return err
}
for _, v := range vals {
data, _ := marshal(v, opt.generateYaml)
kind := strings.ToLower(v.GetObjectKind().GroupVersionKind().Kind)
print(k, kind, data, opt.toStdout, opt.generateYaml, f)
}
}
}

if f != nil {
fmt.Fprintf(os.Stdout, "file %q created\n", opt.outFile)
return nil
}

// marshal object runtime.Object and return byte array
func marshal(obj runtime.Object, yamlFormat bool) (data []byte, err error) {
// convert data to yaml or json
if yamlFormat {
data, err = yaml.Marshal(obj)
} else {
data, err = json.MarshalIndent(obj, "", " ")
}
return
}

// Convert all objects in objs to versioned objects
func ConvertToVersion(objs []runtime.Object) ([]runtime.Object, error) {
ret := []runtime.Object{}

for _, obj := range objs {

if opt.createChart {
err := generateHelm(opt.inputFile, svcnames, opt.generateYaml, opt.createD, opt.createDS, opt.createRC, opt.outFile)
objectVersion := obj.GetObjectKind().GroupVersionKind()
version := unversioned.GroupVersion{Group: objectVersion.Group, Version: objectVersion.Version}
convertedObject, err := api.Scheme.ConvertToVersion(obj, version)
if err != nil {
logrus.Fatalf("Failed to create Chart data: %v", err)
return nil, err
}
ret = append(ret, convertedObject)
}

if opt.createDeploymentConfig {
for k, v := range mDeploymentConfigs {
print(k, "deploymentconfig", v, opt.toStdout, opt.generateYaml, f)
}
}
return ret, nil
}

// Convert tranforms docker compose or dab file to k8s objects
Expand Down Expand Up @@ -1174,20 +1175,20 @@ func checkUnsupportedKey(service interface{}) {
}
}

// Either print to stdout or to file/s
func print(name, trailing string, data []byte, toStdout, generateYaml bool, f *os.File) {
file := fmt.Sprintf("%s-%s.json", name, trailing)

file := ""
if generateYaml {
file = fmt.Sprintf("%s-%s.yaml", name, trailing)
}
separator := ""
if generateYaml {
separator = "---"
} else {
file = fmt.Sprintf("%s-%s.json", name, trailing)
}
if toStdout {
fmt.Fprintf(os.Stdout, "%s%s\n", string(data), separator)
fmt.Fprintf(os.Stdout, "%s\n", string(data))
} else if f != nil {
// Write all content to a single file f
if _, err := f.WriteString(fmt.Sprintf("%s%s\n", string(data), separator)); err != nil {
if _, err := f.WriteString(fmt.Sprintf("%s\n", string(data))); err != nil {
logrus.Fatalf("Failed to write %s to file: %v", trailing, err)
}
f.Sync()
Expand Down

0 comments on commit 6fe9755

Please sign in to comment.