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 10, 2016
1 parent 14cf356 commit 7fb052f
Show file tree
Hide file tree
Showing 2 changed files with 142 additions and 179 deletions.
268 changes: 134 additions & 134 deletions cli/app/app.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -925,23 +925,27 @@ type convertOptions struct {
}

// Convert komposeObject to K8S controllers
func komposeConvert(komposeObject KomposeObject, opt convertOptions) (map[string][]byte, map[string][]byte, map[string][]byte, map[string][]byte, map[string][]byte, []string) {
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)

func komposeConvert(komposeObject KomposeObject, opt convertOptions) []runtime.Object {
var svcnames []string

// this will hold all the converted data
var objects []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 @@ -1005,101 +1009,115 @@ func komposeConvert(komposeObject KomposeObject, opt convertOptions) (map[string
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)

// 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())
}
// update supported controller
updateController(controller, fillTemplate, fillObjectMeta)

// convert datads to json / yaml
datads, err := transformer(ds, opt.generateYaml)
if err != nil {
logrus.Fatalf(err.Error())
}
// add controller to the list of objects
objects = append(objects, controller)

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 = append(objects, sc)
}
}
return objects
}

// convert OpenShift DeploymentConfig to json / yaml
dataDeploymentConfig, err := transformer(osDC, opt.generateYaml)
if err != nil {
logrus.Fatalf(err.Error())
}
// PrintList will take the data converted and decide on the commandline attributes given
func PrintList(objects []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
var files []string

return mServices, mDeployments, mDaemonSets, mReplicationControllers, mDeploymentConfigs, svcnames
}
// 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{}
list.Items = objects

func printControllers(mServices, mDeployments, mDaemonSets, mReplicationControllers, mDeploymentConfigs map[string][]byte, svcnames []string, opt convertOptions, f *os.File) {
for k, v := range mServices {
if v != nil {
print(k, "svc", v, opt.toStdout, opt.generateYaml, f)
// version each object in the list
list.Items, err = ConvertToVersion(list.Items)
if err != nil {
return err
}
}

// 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)
// version list itself
listVersion := unversioned.GroupVersion{Group: "", Version: "v1"}
convertedList, err := api.Scheme.ConvertToVersion(list, listVersion)
if err != nil {
return err
}
}

if opt.createDS {
for k, v := range mDaemonSets {
print(k, "daemonset", v, opt.toStdout, opt.generateYaml, f)
data, err := marshal(convertedList, opt.generateYaml)
if err != nil {
return fmt.Errorf("Error in marshalling the List: %v", err)
}
}
files = append(files, print("", "", data, opt.toStdout, opt.generateYaml, f))
} else {
var file string
// create a separate file for each provider
for _, v := range objects {
data, err := marshal(v, opt.generateYaml)
if err != nil {
return err
}
switch t := v.(type) {
case *api.ReplicationController:
file = print(t.Name, strings.ToLower(t.Kind), data, opt.toStdout, opt.generateYaml, f)
case *extensions.Deployment:
file = print(t.Name, strings.ToLower(t.Kind), data, opt.toStdout, opt.generateYaml, f)
case *extensions.ReplicaSet:
file = print(t.Name, strings.ToLower(t.Kind), data, opt.toStdout, opt.generateYaml, f)
case *extensions.DaemonSet:
file = print(t.Name, strings.ToLower(t.Kind), data, opt.toStdout, opt.generateYaml, f)
case *deployapi.DeploymentConfig:
file = print(t.Name, strings.ToLower(t.Kind), data, opt.toStdout, opt.generateYaml, f)
case *api.Service:
file = print(t.Name, strings.ToLower(t.Kind), data, opt.toStdout, opt.generateYaml, f)
}
files = append(files, file)

if opt.createRC {
for k, v := range mReplicationControllers {
print(k, "rc", v, opt.toStdout, opt.generateYaml, f)
}
}
if opt.createChart {
generateHelm(opt.inputFile, files)
}
return nil
}

if f != nil {
fmt.Fprintf(os.Stdout, "file %q created\n", opt.outFile)
// 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, "", " ")
}
if err != nil {
data = nil
}
return
}

if opt.createChart {
err := generateHelm(opt.inputFile, svcnames, opt.generateYaml, opt.createD, opt.createDS, opt.createRC, opt.outFile)
// Convert all objects in objs to versioned objects
func ConvertToVersion(objs []runtime.Object) ([]runtime.Object, error) {
ret := []runtime.Object{}

for _, obj := range objs {

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
}

func validateFlags(opt convertOptions, singleOutput bool, dabFile, inputFile string) {
Expand Down Expand Up @@ -1184,13 +1202,10 @@ func Convert(c *cli.Context) {
}

// Convert komposeObject to K8S controllers
mServices, mDeployments, mDaemonSets, mReplicationControllers, mDeploymentConfigs, svcnames := komposeConvert(komposeObject, opt)
objects := komposeConvert(komposeObject, opt)

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

// Print output
printControllers(mServices, mDeployments, mDaemonSets, mReplicationControllers, mDeploymentConfigs, svcnames, opt, f)
// print output to places as needed
PrintList(objects, opt)
}

func checkUnsupportedKey(service interface{}) {
Expand All @@ -1205,20 +1220,21 @@ func checkUnsupportedKey(service interface{}) {
}
}

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

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))
return ""
} 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 All @@ -1227,13 +1243,14 @@ func print(name, trailing string, data []byte, toStdout, generateYaml bool, f *o
if err := ioutil.WriteFile(file, []byte(data), 0644); err != nil {
logrus.Fatalf("Failed to write %s: %v", trailing, err)
}
fmt.Fprintf(os.Stdout, "file %q created\n", file)
logrus.Printf("file %q created", file)
}
return file
}

// Up brings up deployment, svc.
func Up(c *cli.Context) {
fmt.Println("We are going to create Kubernetes deployment and service for your dockerized application. \n" +
logrus.Infoln("We are going to create Kubernetes deployment and service for your dockerized application. \n" +
"If you need more kind of controllers, use 'kompose convert' and 'kubectl create -f' instead. \n")

factory := cmdutil.NewFactory(nil)
Expand All @@ -1249,6 +1266,7 @@ func Up(c *cli.Context) {
komposeObject := KomposeObject{}
opt := convertOptions{
replicas: 1,
createD: true,
}

validateFlags(opt, false, dabFile, inputFile)
Expand All @@ -1259,44 +1277,26 @@ func Up(c *cli.Context) {
komposeObject = loadComposeFile(inputFile)
}

// Convert komposeObject to K8S controllers
mServices, mDeployments, _, _, _, _ := komposeConvert(komposeObject, opt)

// submit svc first
sc := &api.Service{}
for k, v := range mServices {
err := json.Unmarshal(v, &sc)
if err != nil {
logrus.Fatalf("Failed to unmarshal %s to service object: %s\n", k, err)
}
//submit sc to k8s
scCreated, err := client.Services(api.NamespaceDefault).Create(sc)
if err != nil {
logrus.Fatalf("Failed to create service %s: ", k, err)
} else {
fmt.Printf("Service %q has been created.\n", k)
}
logrus.Debugf("%s\n", scCreated)
}
//Convert komposeObject to K8S controllers
objects := komposeConvert(komposeObject, opt)

// then submit dc
dc := &extensions.Deployment{}
for k, v := range mDeployments {
err := json.Unmarshal(v, &dc)
if err != nil {
logrus.Fatalf("Failed to unmarshal %s to deployment controller object: %s\n", k, err)
}
//submit sc to k8s
dcCreated, err := client.Deployments(api.NamespaceDefault).Create(dc)
if err != nil {
logrus.Fatalf("Failed to create deployment controller %s: ", k, err)
} else {
fmt.Printf("Deployment %q has been created.\n", k)
for _, v := range objects {
switch t := v.(type) {
case *extensions.Deployment:
_, err := client.Deployments(api.NamespaceDefault).Create(t)
if err != nil {
logrus.Fatalf("Error creating deployment: %s", t.Name)
}
logrus.Infof("Successfully created deployment: %s", t.Name)
case *api.Service:
_, err := client.Services(api.NamespaceDefault).Create(t)
if err != nil {
logrus.Fatalf("Error creating service: %s", t.Name)
}
logrus.Infof("Successfully created service: %s", t.Name)
}
logrus.Debugf("%s\n", dcCreated)
}

fmt.Println("\nApplication has been deployed to Kubernetes. You can run 'kubectl get deployment,svc' for details.")
logrus.Infof("\nApplication has been deployed to Kubernetes. You can run 'kubectl get deployment,svc' for details.")
}

// updateController updates the given object with the given pod template update function and ObjectMeta update function
Expand Down
Loading

0 comments on commit 7fb052f

Please sign in to comment.