github.com/fastly/cli@v1.7.2-0.20240304164155-9d0f1d77c3bf/pkg/commands/vcl/custom/create.go (about)

     1  package custom
     2  
     3  import (
     4  	"io"
     5  
     6  	"github.com/fastly/go-fastly/v9/fastly"
     7  
     8  	"github.com/fastly/cli/pkg/argparser"
     9  	"github.com/fastly/cli/pkg/errors"
    10  	"github.com/fastly/cli/pkg/global"
    11  	"github.com/fastly/cli/pkg/text"
    12  )
    13  
    14  // NewCreateCommand returns a usable command registered under the parent.
    15  func NewCreateCommand(parent argparser.Registerer, g *global.Data) *CreateCommand {
    16  	c := CreateCommand{
    17  		Base: argparser.Base{
    18  			Globals: g,
    19  		},
    20  	}
    21  	c.CmdClause = parent.Command("create", "Upload a VCL for a particular service and version").Alias("add")
    22  
    23  	// Required.
    24  	c.CmdClause.Flag("content", "VCL passed as file path or content, e.g. $(< main.vcl)").Action(c.content.Set).StringVar(&c.content.Value)
    25  	c.RegisterFlag(argparser.StringFlagOpts{
    26  		Name:        argparser.FlagVersionName,
    27  		Description: argparser.FlagVersionDesc,
    28  		Dst:         &c.serviceVersion.Value,
    29  		Required:    true,
    30  	})
    31  
    32  	// Optional.
    33  	c.RegisterAutoCloneFlag(argparser.AutoCloneFlagOpts{
    34  		Action: c.autoClone.Set,
    35  		Dst:    &c.autoClone.Value,
    36  	})
    37  	c.CmdClause.Flag("main", "Whether the VCL is the 'main' entrypoint").Action(c.main.Set).BoolVar(&c.main.Value)
    38  	c.CmdClause.Flag("name", "The name of the VCL").Action(c.name.Set).StringVar(&c.name.Value)
    39  	c.RegisterFlag(argparser.StringFlagOpts{
    40  		Name:        argparser.FlagServiceIDName,
    41  		Description: argparser.FlagServiceIDDesc,
    42  		Dst:         &g.Manifest.Flag.ServiceID,
    43  		Short:       's',
    44  	})
    45  	c.RegisterFlag(argparser.StringFlagOpts{
    46  		Action:      c.serviceName.Set,
    47  		Name:        argparser.FlagServiceName,
    48  		Description: argparser.FlagServiceDesc,
    49  		Dst:         &c.serviceName.Value,
    50  	})
    51  
    52  	return &c
    53  }
    54  
    55  // CreateCommand calls the Fastly API to create an appropriate resource.
    56  type CreateCommand struct {
    57  	argparser.Base
    58  
    59  	autoClone      argparser.OptionalAutoClone
    60  	content        argparser.OptionalString
    61  	main           argparser.OptionalBool
    62  	name           argparser.OptionalString
    63  	serviceName    argparser.OptionalServiceNameID
    64  	serviceVersion argparser.OptionalServiceVersion
    65  }
    66  
    67  // Exec invokes the application logic for the command.
    68  func (c *CreateCommand) Exec(_ io.Reader, out io.Writer) error {
    69  	serviceID, serviceVersion, err := argparser.ServiceDetails(argparser.ServiceDetailsOpts{
    70  		AutoCloneFlag:      c.autoClone,
    71  		APIClient:          c.Globals.APIClient,
    72  		Manifest:           *c.Globals.Manifest,
    73  		Out:                out,
    74  		ServiceNameFlag:    c.serviceName,
    75  		ServiceVersionFlag: c.serviceVersion,
    76  		VerboseMode:        c.Globals.Flags.Verbose,
    77  	})
    78  	if err != nil {
    79  		c.Globals.ErrLog.AddWithContext(err, map[string]any{
    80  			"Service ID":      serviceID,
    81  			"Service Version": errors.ServiceVersion(serviceVersion),
    82  		})
    83  		return err
    84  	}
    85  
    86  	input := c.constructInput(serviceID, fastly.ToValue(serviceVersion.Number))
    87  
    88  	v, err := c.Globals.APIClient.CreateVCL(input)
    89  	if err != nil {
    90  		c.Globals.ErrLog.AddWithContext(err, map[string]any{
    91  			"Service ID":      serviceID,
    92  			"Service Version": fastly.ToValue(serviceVersion.Number),
    93  		})
    94  		return err
    95  	}
    96  
    97  	text.Success(out,
    98  		"Created custom VCL '%s' (service: %s, version: %d, main: %t)",
    99  		fastly.ToValue(v.Name),
   100  		fastly.ToValue(v.ServiceID),
   101  		fastly.ToValue(v.ServiceVersion),
   102  		fastly.ToValue(v.Main),
   103  	)
   104  	return nil
   105  }
   106  
   107  // constructInput transforms values parsed from CLI flags into an object to be used by the API client library.
   108  func (c *CreateCommand) constructInput(serviceID string, serviceVersion int) *fastly.CreateVCLInput {
   109  	input := fastly.CreateVCLInput{
   110  		ServiceID:      serviceID,
   111  		ServiceVersion: serviceVersion,
   112  	}
   113  	if c.name.WasSet {
   114  		input.Name = &c.name.Value
   115  	}
   116  	if c.content.WasSet {
   117  		input.Content = fastly.ToPointer(argparser.Content(c.content.Value))
   118  	}
   119  	if c.main.WasSet {
   120  		input.Main = fastly.ToPointer(c.main.Value)
   121  	}
   122  	return &input
   123  }