podModify.go

package cmd

import (
	"fmt"

	"github.com/lf-edge/eden/pkg/defaults"
	"github.com/lf-edge/eden/pkg/expect"
	"github.com/lf-edge/eden/pkg/utils"
	"github.com/lf-edge/eve/api/go/config"
	log "github.com/sirupsen/logrus"
	"github.com/spf13/cobra"
)

//podModifyCmd is a command to modify app
var podModifyCmd = &cobra.Command{
	Use:   "modify <app>",
	Short: "Modify pod",
	Args:  cobra.ExactArgs(1),
	PreRunE: func(cmd *cobra.Command, args []string) error {
		assignCobraToViper(cmd)
		_, err := utils.LoadConfigFile(configFile)
		if err != nil {
			return fmt.Errorf("error reading config: %s", err.Error())
		}
		return nil
	},
	Run: func(cmd *cobra.Command, args []string) {
		appName := args[0]
		changer := &adamChanger{}
		ctrl, dev, err := changer.getControllerAndDev()
		if err != nil {
			log.Fatalf("getControllerAndDev: %s", err)
		}
		for _, appID := range dev.GetApplicationInstances() {
			app, err := ctrl.GetApplicationInstanceConfig(appID)
			if err != nil {
				log.Fatalf("no app in cloud %s: %s", appID, err)
			}
			if app.Displayname == appName {
				portPublishCombined := portPublish
				if !cmd.Flags().Changed("publish") {
					portPublishCombined = []string{}
					for _, intf := range app.Interfaces {
						for _, acls := range intf.Acls {
							lport := ""
							var appPort uint32
							for _, match := range acls.Matches {
								if match.Type == "lport" {
									lport = match.Value
									break
								}
							}
							for _, action := range acls.Actions {
								if action.Portmap {
									appPort = action.AppPort
									break
								}
							}
							if lport != "" && appPort != 0 {
								portPublishCombined = append(portPublishCombined, fmt.Sprintf("%s:%d", lport, appPort))
							}
						}
					}
				}
				var opts []expect.ExpectationOption
				if len(podNetworks) > 0 {
					for i, el := range podNetworks {
						if i == 0 {
							//allocate ports on first network
							opts = append(opts, expect.AddNetInstanceNameAndPortPublish(el, portPublishCombined))
						} else {
							opts = append(opts, expect.AddNetInstanceNameAndPortPublish(el, nil))
						}
					}
				} else {
					opts = append(opts, expect.WithPortsPublish(portPublishCombined))
				}
				opts = append(opts, expect.WithACL(processAcls(acl)))
				opts = append(opts, expect.WithOldApp(appName))
				expectation := expect.AppExpectationFromURL(ctrl, dev, defaults.DefaultDummyExpect, appName, opts...)
				appInstanceConfig := expectation.Application()
				needPurge := false
				if len(app.Interfaces) != len(appInstanceConfig.Interfaces) {
					needPurge = true
				} else {
					for ind, el := range app.Interfaces {
						equals, err := utils.CompareProtoMessages(el, appInstanceConfig.Interfaces[ind])
						if err != nil {
							log.Fatalf("CompareMessages: %v", err)
						}
						if !equals {
							needPurge = true
							break
						}
					}
				}
				if needPurge {
					if app.Purge == nil {
						app.Purge = &config.InstanceOpsCmd{Counter: 0}
					}
					app.Purge.Counter++
				}
				//now we only change networks
				app.Interfaces = appInstanceConfig.Interfaces
				if err = changer.setControllerAndDev(ctrl, dev); err != nil {
					log.Fatalf("setControllerAndDev: %s", err)
				}
				log.Infof("app %s modify done", appName)
				return
			}
		}
		log.Infof("not found app with name %s", appName)
	},
}

func podModifyInit() {
	podCmd.AddCommand(podModifyCmd)
	podModifyCmd.Flags().StringSliceVarP(&portPublish, "publish", "p", nil, "Ports to publish in format EXTERNAL_PORT:INTERNAL_PORT")
	podModifyCmd.Flags().BoolVar(&aclOnlyHost, "only-host", false, "Allow access only to host and external networks")
	podModifyCmd.Flags().StringSliceVar(&podNetworks, "networks", nil, "Networks to connect to app (ports will be mapped to first network)")
	podModifyCmd.Flags().StringSliceVar(&acl, "acl", nil, `Allow access only to defined hosts/ips/subnets
You can set acl for particular network in format '<network_name:acl>'
To remove acls you can set empty line '<network_name>:'`)
}