get.porter.sh/porter@v1.3.0/pkg/porter/version.go (about)

     1  package porter
     2  
     3  import (
     4  	"bytes"
     5  	"context"
     6  	"fmt"
     7  	"runtime"
     8  	"text/template"
     9  
    10  	"get.porter.sh/porter/pkg"
    11  	"get.porter.sh/porter/pkg/mixin"
    12  	"get.porter.sh/porter/pkg/pkgmgmt"
    13  	"get.porter.sh/porter/pkg/porter/version"
    14  	"get.porter.sh/porter/pkg/printer"
    15  	"get.porter.sh/porter/pkg/tracing"
    16  )
    17  
    18  type VersionOpts struct {
    19  	version.Options
    20  	System bool
    21  }
    22  
    23  type SystemInfo struct {
    24  	OS   string
    25  	Arch string
    26  }
    27  
    28  type Mixins []mixin.Metadata
    29  
    30  type SystemDebugInfo struct {
    31  	Version pkgmgmt.PackageMetadata `json:"version"`
    32  	SysInfo SystemInfo              `json:"system"`
    33  	Mixins  Mixins                  `json:"mixins"`
    34  }
    35  
    36  func (mixins Mixins) PrintMixinsTable() string {
    37  	buffer := &bytes.Buffer{}
    38  	printMixinRow :=
    39  		func(v interface{}) []string {
    40  			m, ok := v.(mixin.Metadata)
    41  			if !ok {
    42  				return nil
    43  			}
    44  			return []string{m.Name, m.VersionInfo.Version, m.VersionInfo.Author}
    45  		}
    46  	err := printer.PrintTable(buffer, mixins, printMixinRow, "Name", "Version", "Author")
    47  	if err != nil {
    48  		return ""
    49  	}
    50  	return buffer.String()
    51  }
    52  
    53  func (p *Porter) PrintVersion(ctx context.Context, opts VersionOpts) error {
    54  	metadata := pkgmgmt.Metadata{
    55  		Name: "porter",
    56  		VersionInfo: pkgmgmt.VersionInfo{
    57  			Version: pkg.Version,
    58  			Commit:  pkg.Commit,
    59  		},
    60  	}
    61  
    62  	if opts.System {
    63  		return p.PrintDebugInfo(ctx, opts, metadata)
    64  	}
    65  
    66  	return version.PrintVersion(p.Context, opts.Options, metadata)
    67  }
    68  
    69  func getSystemInfo() *SystemInfo {
    70  	return &SystemInfo{
    71  		OS:   runtime.GOOS,
    72  		Arch: runtime.GOARCH,
    73  	}
    74  }
    75  
    76  func (p *Porter) PrintDebugInfo(ctx context.Context, opts VersionOpts, metadata pkgmgmt.Metadata) error {
    77  	log := tracing.LoggerFromContext(ctx)
    78  
    79  	opts.RawFormat = string(printer.FormatPlaintext)
    80  	sysInfo := getSystemInfo()
    81  	mixins, err := p.ListMixins(ctx)
    82  	if err != nil {
    83  		log.Debug(err.Error())
    84  		return nil
    85  	}
    86  
    87  	sysDebugInfo := SystemDebugInfo{
    88  		Version: metadata,
    89  		SysInfo: *sysInfo,
    90  		Mixins:  mixins,
    91  	}
    92  
    93  	switch opts.Format {
    94  	case printer.FormatJson:
    95  		return printer.PrintJson(p.Out, sysDebugInfo)
    96  	case printer.FormatPlaintext:
    97  		plaintextTmpl := `{{.Version.Name}} {{.Version.VersionInfo.Version}} ({{.Version.VersionInfo.Commit}})
    98  
    99  System
   100  -------
   101  os: {{.SysInfo.OS}}
   102  arch: {{.SysInfo.Arch}}
   103  {{if .Mixins}}
   104  Mixins
   105  {{.Mixins.PrintMixinsTable}}{{end}}
   106  `
   107  		tmpl, err := template.New("systemDebugInfo").Parse(plaintextTmpl)
   108  		if err != nil {
   109  			return log.Error(fmt.Errorf("Failed to parse plaintext template: %w", err))
   110  		}
   111  		err = tmpl.Execute(p.Out, sysDebugInfo)
   112  		return log.Error(err)
   113  	default:
   114  		return log.Error(fmt.Errorf("unsupported format: %s", opts.Format))
   115  	}
   116  }