github.com/LukasHeimann/cloudfoundrycli/v8@v8.4.4/command/v7/copy_source_command.go (about)

     1  package v7
     2  
     3  import (
     4  	"github.com/LukasHeimann/cloudfoundrycli/v8/actor/v7action"
     5  	"github.com/LukasHeimann/cloudfoundrycli/v8/api/cloudcontroller/ccv3/constant"
     6  	"github.com/LukasHeimann/cloudfoundrycli/v8/api/logcache"
     7  	"github.com/LukasHeimann/cloudfoundrycli/v8/command"
     8  	"github.com/LukasHeimann/cloudfoundrycli/v8/command/flag"
     9  	"github.com/LukasHeimann/cloudfoundrycli/v8/command/translatableerror"
    10  	"github.com/LukasHeimann/cloudfoundrycli/v8/command/v7/shared"
    11  	"github.com/LukasHeimann/cloudfoundrycli/v8/util/configv3"
    12  )
    13  
    14  type CopySourceCommand struct {
    15  	BaseCommand
    16  
    17  	RequiredArgs        flag.CopySourceArgs     `positional-args:"yes"`
    18  	usage               interface{}             `usage:"CF_NAME copy-source SOURCE_APP DESTINATION_APP [-s TARGET_SPACE [-o TARGET_ORG]] [--no-restart] [--strategy STRATEGY] [--no-wait]"`
    19  	Strategy            flag.DeploymentStrategy `long:"strategy" description:"Deployment strategy, either rolling or null"`
    20  	NoWait              bool                    `long:"no-wait" description:"Exit when the first instance of the web process is healthy"`
    21  	NoRestart           bool                    `long:"no-restart" description:"Do not restage the destination application"`
    22  	Organization        string                  `short:"o" long:"organization" description:"Org that contains the destination application"`
    23  	Space               string                  `short:"s" long:"space" description:"Space that contains the destination application"`
    24  	relatedCommands     interface{}             `related_commands:"apps, push, restage, restart, target"`
    25  	envCFStagingTimeout interface{}             `environmentName:"CF_STAGING_TIMEOUT" environmentDescription:"Max wait time for staging, in minutes" environmentDefault:"15"`
    26  	envCFStartupTimeout interface{}             `environmentName:"CF_STARTUP_TIMEOUT" environmentDescription:"Max wait time for app instance startup, in minutes" environmentDefault:"5"`
    27  
    28  	Stager shared.AppStager
    29  }
    30  
    31  func (cmd *CopySourceCommand) ValidateFlags() error {
    32  	if cmd.Organization != "" && cmd.Space == "" {
    33  		return translatableerror.RequiredFlagsError{
    34  			Arg1: "--organization, -o",
    35  			Arg2: "--space, -s",
    36  		}
    37  	}
    38  
    39  	if cmd.NoRestart && cmd.Strategy.Name != constant.DeploymentStrategyDefault {
    40  		return translatableerror.ArgumentCombinationError{
    41  			Args: []string{"--no-restart", "--strategy"},
    42  		}
    43  	}
    44  
    45  	if cmd.NoRestart && cmd.NoWait {
    46  		return translatableerror.ArgumentCombinationError{
    47  			Args: []string{"--no-restart", "--no-wait"},
    48  		}
    49  	}
    50  
    51  	return nil
    52  }
    53  
    54  func (cmd *CopySourceCommand) Setup(config command.Config, ui command.UI) error {
    55  	err := cmd.BaseCommand.Setup(config, ui)
    56  	if err != nil {
    57  		return err
    58  	}
    59  
    60  	logCacheClient, err := logcache.NewClient(config.LogCacheEndpoint(), config, ui, v7action.NewDefaultKubernetesConfigGetter())
    61  	if err != nil {
    62  		return err
    63  	}
    64  
    65  	cmd.Stager = shared.NewAppStager(cmd.Actor, cmd.UI, cmd.Config, logCacheClient)
    66  
    67  	return nil
    68  }
    69  
    70  func (cmd CopySourceCommand) Execute(args []string) error {
    71  	err := cmd.SharedActor.CheckTarget(true, true)
    72  	if err != nil {
    73  		return err
    74  	}
    75  
    76  	user, err := cmd.Actor.GetCurrentUser()
    77  	if err != nil {
    78  		return err
    79  	}
    80  
    81  	err = cmd.ValidateFlags()
    82  	if err != nil {
    83  		return err
    84  	}
    85  
    86  	targetOrgName := cmd.Config.TargetedOrganization().Name
    87  	targetSpaceName := cmd.Config.TargetedSpace().Name
    88  	if cmd.Organization != "" {
    89  		targetOrgName = cmd.Organization
    90  	}
    91  	if cmd.Space != "" {
    92  		targetSpaceName = cmd.Space
    93  	}
    94  
    95  	cmd.UI.DisplayTextWithFlavor(
    96  		"Copying source from app {{.SourceApp}} to target app {{.TargetApp}} in org {{.Org}} / space {{.Space}} as {{.UserName}}...",
    97  		map[string]interface{}{
    98  			"SourceApp": cmd.RequiredArgs.SourceAppName,
    99  			"TargetApp": cmd.RequiredArgs.TargetAppName,
   100  			"Org":       targetOrgName,
   101  			"Space":     targetSpaceName,
   102  			"UserName":  user.Name,
   103  		},
   104  	)
   105  	cmd.UI.DisplayNewline()
   106  
   107  	targetOrg := cmd.Config.TargetedOrganization()
   108  	targetSpace := cmd.Config.TargetedSpace()
   109  	if cmd.Organization != "" {
   110  		org, warnings, err := cmd.Actor.GetOrganizationByName(cmd.Organization)
   111  		cmd.UI.DisplayWarnings(warnings)
   112  		if err != nil {
   113  			return err
   114  		}
   115  		targetOrg = configv3.Organization{
   116  			GUID: org.GUID,
   117  			Name: org.Name,
   118  		}
   119  	}
   120  	if cmd.Space != "" {
   121  		space, warnings, err := cmd.Actor.GetSpaceByNameAndOrganization(cmd.Space, targetOrg.GUID)
   122  		cmd.UI.DisplayWarnings(warnings)
   123  		if err != nil {
   124  			return err
   125  		}
   126  		targetSpace = configv3.Space{
   127  			GUID: space.GUID,
   128  			Name: space.Name,
   129  		}
   130  	}
   131  
   132  	sourceApp, warnings, err := cmd.Actor.GetApplicationByNameAndSpace(cmd.RequiredArgs.SourceAppName, cmd.Config.TargetedSpace().GUID)
   133  	cmd.UI.DisplayWarnings(warnings)
   134  	if err != nil {
   135  		return err
   136  	}
   137  
   138  	targetApp, warnings, err := cmd.Actor.GetApplicationByNameAndSpace(cmd.RequiredArgs.TargetAppName, targetSpace.GUID)
   139  	cmd.UI.DisplayWarnings(warnings)
   140  	if err != nil {
   141  		return err
   142  	}
   143  
   144  	pkg, warnings, err := cmd.Actor.CopyPackage(sourceApp, targetApp)
   145  	cmd.UI.DisplayWarnings(warnings)
   146  	if err != nil {
   147  		return err
   148  	}
   149  
   150  	if !cmd.NoRestart {
   151  		cmd.UI.DisplayTextWithFlavor(
   152  			"Staging app {{.TargetApp}} in org {{.TargetOrg}} / space {{.TargetSpace}} as {{.UserName}}...",
   153  			map[string]interface{}{
   154  				"TargetApp":   cmd.RequiredArgs.TargetAppName,
   155  				"TargetOrg":   targetOrgName,
   156  				"TargetSpace": targetSpaceName,
   157  				"UserName":    user.Name,
   158  			},
   159  		)
   160  		cmd.UI.DisplayNewline()
   161  
   162  		err = cmd.Stager.StageAndStart(
   163  			targetApp,
   164  			targetSpace,
   165  			targetOrg,
   166  			pkg.GUID,
   167  			cmd.Strategy.Name,
   168  			cmd.NoWait,
   169  			constant.ApplicationRestarting,
   170  		)
   171  		if err != nil {
   172  			return mapErr(cmd.Config, targetApp.Name, err)
   173  		}
   174  	} else {
   175  		cmd.UI.DisplayOK()
   176  	}
   177  
   178  	return nil
   179  }