github.com/fastly/cli@v1.7.2-0.20240304164155-9d0f1d77c3bf/pkg/commands/logging/newrelicotlp/list.go (about)

     1  package newrelicotlp
     2  
     3  import (
     4  	"fmt"
     5  	"io"
     6  
     7  	"github.com/fastly/go-fastly/v9/fastly"
     8  
     9  	"github.com/fastly/cli/pkg/argparser"
    10  	fsterr "github.com/fastly/cli/pkg/errors"
    11  	"github.com/fastly/cli/pkg/global"
    12  	"github.com/fastly/cli/pkg/text"
    13  )
    14  
    15  // NewListCommand returns a usable command registered under the parent.
    16  func NewListCommand(parent argparser.Registerer, g *global.Data) *ListCommand {
    17  	c := ListCommand{
    18  		Base: argparser.Base{
    19  			Globals: g,
    20  		},
    21  	}
    22  	c.CmdClause = parent.Command("list", "List all of the New Relic OTLP Logs logging objects for a particular service and version")
    23  
    24  	// Required.
    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.RegisterFlagBool(c.JSONFlag()) // --json
    34  	c.RegisterFlag(argparser.StringFlagOpts{
    35  		Name:        argparser.FlagServiceIDName,
    36  		Description: argparser.FlagServiceIDDesc,
    37  		Dst:         &g.Manifest.Flag.ServiceID,
    38  		Short:       's',
    39  	})
    40  	c.RegisterFlag(argparser.StringFlagOpts{
    41  		Action:      c.serviceName.Set,
    42  		Name:        argparser.FlagServiceName,
    43  		Description: argparser.FlagServiceDesc,
    44  		Dst:         &c.serviceName.Value,
    45  	})
    46  
    47  	return &c
    48  }
    49  
    50  // ListCommand calls the Fastly API to list appropriate resources.
    51  type ListCommand struct {
    52  	argparser.Base
    53  	argparser.JSONOutput
    54  
    55  	serviceName    argparser.OptionalServiceNameID
    56  	serviceVersion argparser.OptionalServiceVersion
    57  }
    58  
    59  // Exec invokes the application logic for the command.
    60  func (c *ListCommand) Exec(_ io.Reader, out io.Writer) error {
    61  	if c.Globals.Verbose() && c.JSONOutput.Enabled {
    62  		return fsterr.ErrInvalidVerboseJSONCombo
    63  	}
    64  
    65  	serviceID, serviceVersion, err := argparser.ServiceDetails(argparser.ServiceDetailsOpts{
    66  		AllowActiveLocked:  true,
    67  		APIClient:          c.Globals.APIClient,
    68  		Manifest:           *c.Globals.Manifest,
    69  		Out:                out,
    70  		ServiceNameFlag:    c.serviceName,
    71  		ServiceVersionFlag: c.serviceVersion,
    72  		VerboseMode:        c.Globals.Flags.Verbose,
    73  	})
    74  	if err != nil {
    75  		c.Globals.ErrLog.AddWithContext(err, map[string]any{
    76  			"Service ID":      serviceID,
    77  			"Service Version": fsterr.ServiceVersion(serviceVersion),
    78  		})
    79  		return err
    80  	}
    81  
    82  	input := c.constructInput(serviceID, fastly.ToValue(serviceVersion.Number))
    83  
    84  	o, err := c.Globals.APIClient.ListNewRelicOTLP(input)
    85  	if err != nil {
    86  		c.Globals.ErrLog.AddWithContext(err, map[string]any{
    87  			"Service ID":      serviceID,
    88  			"Service Version": fastly.ToValue(serviceVersion.Number),
    89  		})
    90  		return err
    91  	}
    92  
    93  	if ok, err := c.WriteJSON(out, o); ok {
    94  		return err
    95  	}
    96  
    97  	if c.Globals.Verbose() {
    98  		c.printVerbose(out, fastly.ToValue(serviceVersion.Number), o)
    99  	} else {
   100  		err = c.printSummary(out, o)
   101  		if err != nil {
   102  			return err
   103  		}
   104  	}
   105  	return nil
   106  }
   107  
   108  // constructInput transforms values parsed from CLI flags into an object to be used by the API client library.
   109  func (c *ListCommand) constructInput(serviceID string, serviceVersion int) *fastly.ListNewRelicOTLPInput {
   110  	var input fastly.ListNewRelicOTLPInput
   111  
   112  	input.ServiceID = serviceID
   113  	input.ServiceVersion = serviceVersion
   114  
   115  	return &input
   116  }
   117  
   118  // printVerbose displays the information returned from the API in a verbose
   119  // format.
   120  func (c *ListCommand) printVerbose(out io.Writer, serviceVersion int, ls []*fastly.NewRelicOTLP) {
   121  	fmt.Fprintf(out, "Service Version: %d\n", serviceVersion)
   122  
   123  	for _, l := range ls {
   124  		fmt.Fprintf(out, "\nName: %s\n", fastly.ToValue(l.Name))
   125  		fmt.Fprintf(out, "\nToken: %s\n", fastly.ToValue(l.Token))
   126  		fmt.Fprintf(out, "\nFormat: %s\n", fastly.ToValue(l.Format))
   127  		fmt.Fprintf(out, "\nFormat Version: %d\n", fastly.ToValue(l.FormatVersion))
   128  		fmt.Fprintf(out, "\nPlacement: %s\n", fastly.ToValue(l.Placement))
   129  		fmt.Fprintf(out, "\nRegion: %s\n", fastly.ToValue(l.Region))
   130  		fmt.Fprintf(out, "\nResponse Condition: %s\n\n", fastly.ToValue(l.ResponseCondition))
   131  
   132  		if l.CreatedAt != nil {
   133  			fmt.Fprintf(out, "Created at: %s\n", l.CreatedAt)
   134  		}
   135  		if l.UpdatedAt != nil {
   136  			fmt.Fprintf(out, "Updated at: %s\n", l.UpdatedAt)
   137  		}
   138  		if l.DeletedAt != nil {
   139  			fmt.Fprintf(out, "Deleted at: %s\n", l.DeletedAt)
   140  		}
   141  	}
   142  }
   143  
   144  // printSummary displays the information returned from the API in a summarised
   145  // format.
   146  func (c *ListCommand) printSummary(out io.Writer, nrs []*fastly.NewRelicOTLP) error {
   147  	t := text.NewTable(out)
   148  	t.AddHeader("SERVICE ID", "VERSION", "NAME")
   149  	for _, nr := range nrs {
   150  		t.AddLine(
   151  			fastly.ToValue(nr.ServiceID),
   152  			fastly.ToValue(nr.ServiceVersion),
   153  			fastly.ToValue(nr.Name),
   154  		)
   155  	}
   156  	t.Print()
   157  	return nil
   158  }