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

     1  package v7
     2  
     3  import (
     4  	"github.com/LukasHeimann/cloudfoundrycli/v8/actor/actionerror"
     5  	"github.com/LukasHeimann/cloudfoundrycli/v8/command/flag"
     6  )
     7  
     8  type MapRouteCommand struct {
     9  	BaseCommand
    10  
    11  	RequiredArgs flag.AppDomain   `positional-args:"yes"`
    12  	Hostname     string           `long:"hostname" short:"n" description:"Hostname for the HTTP route (required for shared domains)"`
    13  	Path         flag.V7RoutePath `long:"path" description:"Path for the HTTP route"`
    14  	Port         int              `long:"port" description:"Port for the TCP route (default: random port)"`
    15  	AppProtocol  string           `long:"app-protocol" description:"[Beta flag, subject to change] Protocol for the route destination (default: http1). Only applied to HTTP routes"`
    16  
    17  	relatedCommands interface{} `related_commands:"create-route, routes, unmap-route"`
    18  }
    19  
    20  func (cmd MapRouteCommand) Usage() string {
    21  	return `
    22  Map an HTTP route:
    23     CF_NAME map-route APP_NAME DOMAIN [--hostname HOSTNAME] [--path PATH] [--app-protocol PROTOCOL]
    24  
    25  Map a TCP route:
    26     CF_NAME map-route APP_NAME DOMAIN [--port PORT]`
    27  }
    28  
    29  func (cmd MapRouteCommand) Examples() string {
    30  	return `
    31  CF_NAME map-route my-app example.com                                                # example.com
    32  CF_NAME map-route my-app example.com --hostname myhost                              # myhost.example.com
    33  CF_NAME map-route my-app example.com --hostname myhost --path foo                   # myhost.example.com/foo
    34  CF_NAME map-route my-app example.com --hostname myhost --app-protocol http2 # myhost.example.com
    35  CF_NAME map-route my-app example.com --port 5000                                    # example.com:5000`
    36  }
    37  
    38  func (cmd MapRouteCommand) Execute(args []string) error {
    39  	err := cmd.SharedActor.CheckTarget(true, true)
    40  	if err != nil {
    41  		return err
    42  	}
    43  
    44  	user, err := cmd.Actor.GetCurrentUser()
    45  	if err != nil {
    46  		return err
    47  	}
    48  
    49  	domain, warnings, err := cmd.Actor.GetDomainByName(cmd.RequiredArgs.Domain)
    50  	cmd.UI.DisplayWarnings(warnings)
    51  	if err != nil {
    52  		return err
    53  	}
    54  
    55  	spaceGUID := cmd.Config.TargetedSpace().GUID
    56  	app, warnings, err := cmd.Actor.GetApplicationByNameAndSpace(cmd.RequiredArgs.App, spaceGUID)
    57  	cmd.UI.DisplayWarnings(warnings)
    58  	if err != nil {
    59  		return err
    60  	}
    61  
    62  	path := cmd.Path.Path
    63  	route, warnings, err := cmd.Actor.GetRouteByAttributes(domain, cmd.Hostname, path, cmd.Port)
    64  	url := desiredURL(domain.Name, cmd.Hostname, path, cmd.Port)
    65  	cmd.UI.DisplayWarnings(warnings)
    66  	if err != nil {
    67  		if _, ok := err.(actionerror.RouteNotFoundError); !ok {
    68  			return err
    69  		}
    70  		cmd.UI.DisplayTextWithFlavor("Creating route {{.URL}} for org {{.OrgName}} / space {{.SpaceName}} as {{.User}}...",
    71  			map[string]interface{}{
    72  				"URL":       url,
    73  				"User":      user.Name,
    74  				"SpaceName": cmd.Config.TargetedSpace().Name,
    75  				"OrgName":   cmd.Config.TargetedOrganization().Name,
    76  			})
    77  		route, warnings, err = cmd.Actor.CreateRoute(
    78  			cmd.Config.TargetedSpace().GUID,
    79  			domain.Name,
    80  			cmd.Hostname,
    81  			path,
    82  			cmd.Port,
    83  		)
    84  		cmd.UI.DisplayWarnings(warnings)
    85  		if err != nil {
    86  			return err
    87  		}
    88  		cmd.UI.DisplayOK()
    89  	}
    90  
    91  	if cmd.AppProtocol != "" {
    92  		cmd.UI.DisplayTextWithFlavor("Mapping route {{.URL}} to app {{.AppName}} with protocol {{.Protocol}} in org {{.OrgName}} / space {{.SpaceName}} as {{.User}}...", map[string]interface{}{
    93  			"URL":       route.URL,
    94  			"AppName":   cmd.RequiredArgs.App,
    95  			"User":      user.Name,
    96  			"SpaceName": cmd.Config.TargetedSpace().Name,
    97  			"OrgName":   cmd.Config.TargetedOrganization().Name,
    98  			"Protocol":  cmd.AppProtocol,
    99  		})
   100  
   101  	} else {
   102  		cmd.UI.DisplayTextWithFlavor("Mapping route {{.URL}} to app {{.AppName}} in org {{.OrgName}} / space {{.SpaceName}} as {{.User}}...", map[string]interface{}{
   103  			"URL":       route.URL,
   104  			"AppName":   cmd.RequiredArgs.App,
   105  			"User":      user.Name,
   106  			"SpaceName": cmd.Config.TargetedSpace().Name,
   107  			"OrgName":   cmd.Config.TargetedOrganization().Name,
   108  		})
   109  	}
   110  	dest, err := cmd.Actor.GetRouteDestinationByAppGUID(route, app.GUID)
   111  	if err != nil {
   112  		if _, ok := err.(actionerror.RouteDestinationNotFoundError); !ok {
   113  			return err
   114  		}
   115  	}
   116  	if dest.GUID != "" {
   117  		cmd.UI.DisplayText("App '{{ .AppName }}' is already mapped to route '{{ .URL}}'. Nothing has been updated.", map[string]interface{}{
   118  			"AppName": cmd.RequiredArgs.App,
   119  			"URL":     route.URL,
   120  		})
   121  		cmd.UI.DisplayOK()
   122  		return nil
   123  	}
   124  	warnings, err = cmd.Actor.MapRoute(route.GUID, app.GUID, cmd.AppProtocol)
   125  	cmd.UI.DisplayWarnings(warnings)
   126  	if err != nil {
   127  		return err
   128  	}
   129  	cmd.UI.DisplayOK()
   130  
   131  	return nil
   132  }