github.com/drycc/workflow-cli@v1.5.3-0.20240322092846-d4ee25983af9/cmd/routes.go (about)

     1  package cmd
     2  
     3  import (
     4  	"fmt"
     5  	"os"
     6  
     7  	"github.com/drycc/controller-sdk-go/routes"
     8  	"sigs.k8s.io/yaml"
     9  )
    10  
    11  // RoutesCreate create a route to an app.
    12  func (d *DryccCmd) RoutesCreate(appID, name string, procType string, kind string, port int) error {
    13  	s, appID, err := load(d.ConfigFile, appID)
    14  
    15  	if err != nil {
    16  		return err
    17  	}
    18  	d.Printf("Adding route %s to %s... ", name, appID)
    19  
    20  	quit := progress(d.WOut)
    21  	err = routes.New(s.Client, appID, name, procType, kind, port)
    22  	quit <- true
    23  	<-quit
    24  	if d.checkAPICompatibility(s.Client, err) != nil {
    25  		return err
    26  	}
    27  
    28  	d.Println("done")
    29  	return nil
    30  }
    31  
    32  // RoutesList lists routes for the app
    33  func (d *DryccCmd) RoutesList(appID string, results int) error {
    34  	s, appID, err := load(d.ConfigFile, appID)
    35  
    36  	if err != nil {
    37  		return err
    38  	}
    39  	if results == defaultLimit {
    40  		results = s.Limit
    41  	}
    42  
    43  	routes, count, err := routes.List(s.Client, appID, results)
    44  	if d.checkAPICompatibility(s.Client, err) != nil {
    45  		return err
    46  	}
    47  	if count == 0 {
    48  		d.Println(fmt.Sprintf("No routes found in %s app.", appID))
    49  	} else {
    50  		table := d.getDefaultFormatTable([]string{"NAME", "OWNER", "PTYPE", "KIND", "SERVICE-PORT", "GATEWAY", "LISTENER-PORT"})
    51  		for _, route := range routes {
    52  			if len(route.ParentRefs) > 0 {
    53  				for _, gateway := range route.ParentRefs {
    54  					table.Append([]string{
    55  						route.Name,
    56  						route.Owner,
    57  						route.Type,
    58  						route.Kind,
    59  						fmt.Sprint(route.Port),
    60  						gateway.Name,
    61  						fmt.Sprint(gateway.Port),
    62  					})
    63  				}
    64  			} else {
    65  				table.Append([]string{
    66  					route.Name,
    67  					route.Owner,
    68  					route.Type,
    69  					route.Kind,
    70  					fmt.Sprint(route.Port),
    71  					"",
    72  					"",
    73  				})
    74  			}
    75  		}
    76  		table.Render()
    77  	}
    78  	return nil
    79  }
    80  
    81  // RoutesAttach bind a route to gateway.
    82  func (d *DryccCmd) RoutesAttach(appID, name string, port int, gateway string) error {
    83  	s, appID, err := load(d.ConfigFile, appID)
    84  
    85  	if err != nil {
    86  		return err
    87  	}
    88  	d.Printf("Attaching route %s to gateway %s... ", name, gateway)
    89  
    90  	quit := progress(d.WOut)
    91  	err = routes.AttachGateway(s.Client, appID, name, port, gateway)
    92  	quit <- true
    93  	<-quit
    94  	if d.checkAPICompatibility(s.Client, err) != nil {
    95  		return err
    96  	}
    97  
    98  	d.Println("done")
    99  	return nil
   100  }
   101  
   102  // RoutesDetach bind a route to gateway.
   103  func (d *DryccCmd) RoutesDetach(appID, name string, port int, gateway string) error {
   104  	s, appID, err := load(d.ConfigFile, appID)
   105  
   106  	if err != nil {
   107  		return err
   108  	}
   109  	d.Printf("Detaching route %s to gateway %s... ", name, gateway)
   110  
   111  	quit := progress(d.WOut)
   112  	err = routes.DetachGateway(s.Client, appID, name, port, gateway)
   113  	quit <- true
   114  	<-quit
   115  	if d.checkAPICompatibility(s.Client, err) != nil {
   116  		return err
   117  	}
   118  
   119  	d.Println("done")
   120  	return nil
   121  }
   122  
   123  // RoutesGet get rule of route for the app
   124  func (d *DryccCmd) RoutesGet(appID string, name string) error {
   125  	s, appID, err := load(d.ConfigFile, appID)
   126  
   127  	if err != nil {
   128  		return err
   129  	}
   130  
   131  	route, err := routes.GetRule(s.Client, appID, name)
   132  	if d.checkAPICompatibility(s.Client, err) != nil {
   133  		return err
   134  	}
   135  
   136  	var rules []byte
   137  	rules, err = yaml.JSONToYAML([]byte(route))
   138  	if err != nil {
   139  		return err
   140  	}
   141  	d.Println(string(rules))
   142  	return nil
   143  }
   144  
   145  // RoutesSet set rule of route for the app
   146  func (d *DryccCmd) RoutesSet(appID string, name string, ruleFile string) error {
   147  	s, appID, err := load(d.ConfigFile, appID)
   148  	if err != nil {
   149  		return err
   150  	}
   151  
   152  	var contents []byte
   153  	if _, err := os.Stat(ruleFile); err != nil {
   154  		return err
   155  	}
   156  	contents, err = os.ReadFile(ruleFile)
   157  	if err != nil {
   158  		return err
   159  	}
   160  	rules, err := yaml.YAMLToJSON(contents)
   161  	if err != nil {
   162  		return err
   163  	}
   164  	d.Print("Applying rules... ")
   165  	quit := progress(d.WOut)
   166  	err = routes.SetRule(s.Client, appID, name, string(rules))
   167  	quit <- true
   168  	<-quit
   169  	if d.checkAPICompatibility(s.Client, err) != nil {
   170  		return err
   171  	}
   172  	d.Println("done")
   173  	return nil
   174  }
   175  
   176  // RoutesRemove removes a route registered with an app.
   177  func (d *DryccCmd) RoutesRemove(appID, name string) error {
   178  	s, appID, err := load(d.ConfigFile, appID)
   179  
   180  	if err != nil {
   181  		return err
   182  	}
   183  	d.Printf("Removing route %s to %s... ", name, appID)
   184  
   185  	quit := progress(d.WOut)
   186  	err = routes.Delete(s.Client, appID, name)
   187  	quit <- true
   188  	<-quit
   189  	if d.checkAPICompatibility(s.Client, err) != nil {
   190  		return err
   191  	}
   192  
   193  	d.Println("done")
   194  	return nil
   195  }