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

     1  package s3
     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  // ListCommand calls the Fastly API to list Amazon S3 logging endpoints.
    16  type ListCommand struct {
    17  	argparser.Base
    18  	argparser.JSONOutput
    19  
    20  	Input          fastly.ListS3sInput
    21  	serviceName    argparser.OptionalServiceNameID
    22  	serviceVersion argparser.OptionalServiceVersion
    23  }
    24  
    25  // NewListCommand returns a usable command registered under the parent.
    26  func NewListCommand(parent argparser.Registerer, g *global.Data) *ListCommand {
    27  	c := ListCommand{
    28  		Base: argparser.Base{
    29  			Globals: g,
    30  		},
    31  	}
    32  	c.CmdClause = parent.Command("list", "List S3 endpoints on a Fastly service version")
    33  
    34  	// Required.
    35  	c.RegisterFlag(argparser.StringFlagOpts{
    36  		Name:        argparser.FlagVersionName,
    37  		Description: argparser.FlagVersionDesc,
    38  		Dst:         &c.serviceVersion.Value,
    39  		Required:    true,
    40  	})
    41  
    42  	// Optional.
    43  	c.RegisterFlagBool(c.JSONFlag()) // --json
    44  	c.RegisterFlag(argparser.StringFlagOpts{
    45  		Name:        argparser.FlagServiceIDName,
    46  		Description: argparser.FlagServiceIDDesc,
    47  		Dst:         &g.Manifest.Flag.ServiceID,
    48  		Short:       's',
    49  	})
    50  	c.RegisterFlag(argparser.StringFlagOpts{
    51  		Action:      c.serviceName.Set,
    52  		Name:        argparser.FlagServiceName,
    53  		Description: argparser.FlagServiceDesc,
    54  		Dst:         &c.serviceName.Value,
    55  	})
    56  	return &c
    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  	c.Input.ServiceID = serviceID
    83  	c.Input.ServiceVersion = fastly.ToValue(serviceVersion.Number)
    84  
    85  	o, err := c.Globals.APIClient.ListS3s(&c.Input)
    86  	if err != nil {
    87  		c.Globals.ErrLog.Add(err)
    88  		return err
    89  	}
    90  
    91  	if ok, err := c.WriteJSON(out, o); ok {
    92  		return err
    93  	}
    94  
    95  	if !c.Globals.Verbose() {
    96  		tw := text.NewTable(out)
    97  		tw.AddHeader("SERVICE", "VERSION", "NAME")
    98  		for _, s3 := range o {
    99  			tw.AddLine(
   100  				fastly.ToValue(s3.ServiceID),
   101  				fastly.ToValue(s3.ServiceVersion),
   102  				fastly.ToValue(s3.Name),
   103  			)
   104  		}
   105  		tw.Print()
   106  		return nil
   107  	}
   108  
   109  	fmt.Fprintf(out, "Version: %d\n", c.Input.ServiceVersion)
   110  	for i, s3 := range o {
   111  		fmt.Fprintf(out, "\tS3 %d/%d\n", i+1, len(o))
   112  		fmt.Fprintf(out, "\t\tService ID: %s\n", fastly.ToValue(s3.ServiceID))
   113  		fmt.Fprintf(out, "\t\tVersion: %d\n", fastly.ToValue(s3.ServiceVersion))
   114  		fmt.Fprintf(out, "\t\tName: %s\n", fastly.ToValue(s3.Name))
   115  		fmt.Fprintf(out, "\t\tBucket: %s\n", fastly.ToValue(s3.BucketName))
   116  		if s3.AccessKey != nil || s3.SecretKey != nil {
   117  			fmt.Fprintf(out, "\t\tAccess key: %s\n", fastly.ToValue(s3.AccessKey))
   118  			fmt.Fprintf(out, "\t\tSecret key: %s\n", fastly.ToValue(s3.SecretKey))
   119  		}
   120  		if s3.IAMRole != nil {
   121  			fmt.Fprintf(out, "\t\tIAM role: %s\n", fastly.ToValue(s3.IAMRole))
   122  		}
   123  		fmt.Fprintf(out, "\t\tPath: %s\n", fastly.ToValue(s3.Path))
   124  		fmt.Fprintf(out, "\t\tPeriod: %d\n", fastly.ToValue(s3.Period))
   125  		fmt.Fprintf(out, "\t\tGZip level: %d\n", fastly.ToValue(s3.GzipLevel))
   126  		fmt.Fprintf(out, "\t\tFormat: %s\n", fastly.ToValue(s3.Format))
   127  		fmt.Fprintf(out, "\t\tFormat version: %d\n", fastly.ToValue(s3.FormatVersion))
   128  		fmt.Fprintf(out, "\t\tResponse condition: %s\n", fastly.ToValue(s3.ResponseCondition))
   129  		fmt.Fprintf(out, "\t\tMessage type: %s\n", fastly.ToValue(s3.MessageType))
   130  		fmt.Fprintf(out, "\t\tTimestamp format: %s\n", fastly.ToValue(s3.TimestampFormat))
   131  		fmt.Fprintf(out, "\t\tPlacement: %s\n", fastly.ToValue(s3.Placement))
   132  		fmt.Fprintf(out, "\t\tPublic key: %s\n", fastly.ToValue(s3.PublicKey))
   133  		fmt.Fprintf(out, "\t\tRedundancy: %s\n", fastly.ToValue(s3.Redundancy))
   134  		fmt.Fprintf(out, "\t\tServer-side encryption: %s\n", fastly.ToValue(s3.ServerSideEncryption))
   135  		fmt.Fprintf(out, "\t\tServer-side encryption KMS key ID: %s\n", fastly.ToValue(s3.ServerSideEncryption))
   136  		fmt.Fprintf(out, "\t\tFile max bytes: %d\n", fastly.ToValue(s3.FileMaxBytes))
   137  		fmt.Fprintf(out, "\t\tCompression codec: %s\n", fastly.ToValue(s3.CompressionCodec))
   138  	}
   139  	fmt.Fprintln(out)
   140  
   141  	return nil
   142  }