Golang columnize.SimpleFormat函数代码示例

func printAppDetail(a App) {
	var output []string
	var outputEnv []string
	fields := structs.New(a).Fields()

	fmt.Println("\nApplication Details:")

	for _, f := range fields {
		if f.Name() == "Addresses" {
			output = append(output, fmt.Sprintf("%s:\n", f.Name()))
			for _, v := range a.Addresses {
				output = append(output, fmt.Sprintf("……|%s", v))
			}
		} else if f.Name() == "Certificates" {
			output = append(output, fmt.Sprintf("%s:| Use \"--full\" to see certificates", f.Name()))
			output = append(output, fmt.Sprintf("– PrivateKey: |%s\n", a.Certificates["private_key"]))
		} else if f.Name() == "CreatedAt" {
			output = append(output, fmt.Sprintf("%s: | %s\n", f.Name(), utils.FormatTime(a.CreatedAt+"Z")))
		} else if f.Name() == "CurrentDeployments" {
			output = append(output, fmt.Sprintf("%s:\n", f.Name()))
			for k, v := range a.CurrentDeployments {
				output = append(output, fmt.Sprintf("……|%s: %s", k, v))
			}
		} else if f.Name() == "Environment" {
			outputEnv = append(outputEnv, fmt.Sprintf("%s:\n", f.Name()))
			for k, v := range a.Environment {
				outputEnv = append(outputEnv, fmt.Sprintf("%s=%s", k, v))
			}
		} else if f.Name() == "Location" {
			output = append(output, fmt.Sprintf("%s: |Identifier: %s\t UUID: %s\n", f.Name(), a.Location["identifier"], a.Location["uuid"]))
		} else if f.Name() == "Metadata" {
			mdata, _ := json.Marshal(a.Metadata)
			output = append(output, fmt.Sprintf("%s: |%s\n", f.Name(), mdata))
		} else if f.Name() == "Ports" {
			output = append(output, fmt.Sprintf("%s:\n", f.Name()))
			for _, v := range a.Ports {
				output = append(output, fmt.Sprintf("……|%s", v))
			}
		} else if f.Name() == "Rules" {
			output = append(output, fmt.Sprintf("%s:\n", f.Name()))
			for k, v := range a.Rules {
				output = append(output, fmt.Sprintf("……|%s=%v", k, v))
			}
		} else if f.Name() == "SSLPorts" {
			output = append(output, fmt.Sprintf("%s:\n", f.Name()))
			for _, v := range a.SSLPorts {
				output = append(output, fmt.Sprintf("……|%s", v))
			}
		} else if f.Name() == "UpdatedAt" {
			output = append(output, fmt.Sprintf("%s: | %s\n", f.Name(), utils.FormatTime(a.UpdatedAt+"Z")))
		} else {
			output = append(output, fmt.Sprintf("%s: |%v\n", f.Name(), f.Value()))
		}
	}

	fmt.Println(columnize.SimpleFormat(output))
	fmt.Println("\n")
	fmt.Println(columnize.SimpleFormat(outputEnv))
}

func listRun(cmd *cobra.Command, args []string) {
	configDir, err := homedir.Expand(globalFlags.config)
	assert(err)

	machines, err := vm.List(configDir)
	assert(err)

	lines := []string{listHeader}
	for _, machine := range machines {
		var hds, nics []string
		for _, hd := range machine.HDs {
			hds = append(hds, fmt.Sprintf("%s %s", hd.Device, hd.Size))
		}
		for _, nic := range machine.NICs {
			nics = append(nics, fmt.Sprintf("%s %s", nic.Bridge, nic.Mac))
		}

		status, _ := machine.Status(listFlags.TMuxSessionName)

		lines = append(lines, fmt.Sprintf(listScheme,
			machine.Serial,
			machine.Image,
			machine.Memory,
			strings.Join(hds, ","),
			strings.Join(nics, ","),
			status))
	}
	fmt.Println(columnize.SimpleFormat(lines))
}

func (c *AuthCommand) listMethods() int {
	client, err := c.Client()
	if err != nil {
		c.Ui.Error(fmt.Sprintf(
			"Error initializing client: %s", err))
		return 1
	}

	auth, err := client.Sys().ListAuth()
	if err != nil {
		c.Ui.Error(fmt.Sprintf(
			"Error reading auth table: %s", err))
		return 1
	}

	paths := make([]string, 0, len(auth))
	for path := range auth {
		paths = append(paths, path)
	}
	sort.Strings(paths)

	columns := []string{"Path | Type | Description"}
	for _, k := range paths {
		a := auth[k]
		columns = append(columns, fmt.Sprintf(
			"%s | %s | %s", k, a.Type, a.Description))
	}

	c.Ui.Output(columnize.SimpleFormat(columns))
	return 0
}

func showInstances(cmd *cobra.Command, args []string) {
	requireProfile := false
	loadArgumentsFromCluster(cmd.Flags(), requireProfile)
	clusterInfoFromArgs(&instancesFlags, args)

	provider := newProvider()
	instancesFlags = provider.ClusterDefaults(instancesFlags)

	if instancesFlags.Name == "" {
		Exitf("Please specify a name\n")
	}
	instances, err := provider.GetInstances(instancesFlags)
	if err != nil {
		Exitf("Failed to list instances: %v\n", err)
	}
	clusterMembers, err := instances.AsClusterMemberList(log, nil)
	if err != nil {
		Exitf("Failed to fetch instance member data: %v\n", err)
	}

	lines := []string{"Name | Cluster IP | Public IP | Private IP | Machine ID | Options | Extra"}
	for _, i := range instances {
		cm, _ := clusterMembers.Find(i) // ignore errors
		options := []string{}
		if cm.EtcdProxy {
			options = append(options, "etcd-proxy")
		}
		lbIP := strings.TrimSpace(i.LoadBalancerIPv4 + " " + i.LoadBalancerIPv6)
		lines = append(lines, fmt.Sprintf("%s | %s | %s | %s | %s | %s | %s", i.Name, i.ClusterIP, lbIP, i.PrivateIP, cm.MachineID, strings.Join(options, ","), strings.Join(i.Extra, ",")))
	}
	result := columnize.SimpleFormat(lines)
	fmt.Println(result)
}

func (p *cfProvider) ShowDomainRecords(domain string) error {
	id, err := p.zoneID(domain)
	if err != nil {
		return maskAny(err)
	}

	url := apiUrl + fmt.Sprintf("zones/%s/dns_records", id)
	res, err := p.get(url, "application/json")
	if err != nil {
		return maskAny(err)
	}

	records := []CfDnsRecord{}
	if err := res.UnmarshalResult(&records); err != nil {
		return maskAny(err)
	}

	lines := []string{
		"Type | Name | Data",
	}
	for _, r := range records {
		line := fmt.Sprintf("%s | %s | %s", r.Type, trimLength(r.Name, 20), trimLength(r.Content, 60))
		lines = append(lines, line)
	}

	sort.Strings(lines[1:])
	result := columnize.SimpleFormat(lines)
	fmt.Println(result)

	return nil
}

func (this *doProvider) ShowRegions() error {
	// Load regions
	client := NewDOClient(this.token)
	regions, err := RegionList(client)
	if err != nil {
		return err
	}

	lines := []string{
		"Slug | Name | Features | Size",
	}
	for _, r := range regions {
		if !r.Available {
			continue
		}
		line := fmt.Sprintf("%s | %s | %s | %s", r.Slug, r.Name, strings.Join(r.Features, " "), strings.Join(r.Sizes, " "))
		lines = append(lines, line)
	}

	sort.Strings(lines[1:])
	result := columnize.SimpleFormat(lines)
	fmt.Println(result)

	return nil
}

func showClusterInfo(cmd *cobra.Command, args []string) {
	requireProfile := false
	loadArgumentsFromCluster(cmd.Flags(), requireProfile)
	clusterInfoFromArgs(&clusterInfoFlags, args)

	provider := newProvider()
	clusterInfoFlags = provider.ClusterDefaults(clusterInfoFlags)

	if clusterInfoFlags.Name == "" {
		Exitf("Please specify a name\n")
	}
	instances, err := provider.GetInstances(clusterInfoFlags)
	if err != nil {
		Exitf("Failed to list instances: %v\n", err)
	}
	clusterMembers, err := instances.AsClusterMemberList(log, nil)
	if err != nil {
		Exitf("Failed to fetch instance member data: %v\n", err)
	}

	lines := []string{
		fmt.Sprintf("ID | %s", clusterMembers[0].ClusterID),
		fmt.Sprintf("#Instances | %d", len(instances)),
	}
	result := columnize.SimpleFormat(lines)
	fmt.Println(result)
}

func (this *Alias) Run(args []string) (exitCode int) {
	cmdFlags := flag.NewFlagSet("alias", flag.ContinueOnError)
	cmdFlags.Usage = func() { this.Ui.Output(this.Help()) }
	if err := cmdFlags.Parse(args); err != nil {
		return 1
	}

	aliases := ctx.AliasesWithValue()
	sortedNames := make([]string, 0, len(aliases))
	for name, _ := range aliases {
		sortedNames = append(sortedNames, name)
	}
	sort.Strings(sortedNames)

	lines := make([]string, 0, len(aliases)+1)
	header := "Alias|Command"
	lines = append(lines, header)
	for _, name := range sortedNames {
		lines = append(lines, fmt.Sprintf("%s|%s", name, aliases[name]))
	}

	fmt.Println(columnize.SimpleFormat(lines))

	return
}

func runInstances(args []string) (exit int) {
	if len(args) == 0 {
		return exitError("no Swarm given. Usage: kocho instances <swarm>")
	} else if len(args) > 1 {
		return exitError("too many arguments. Usage: kocho instances <swarm>")
	}
	swarmName := args[0]

	s, err := swarmService.Get(swarmName, swarm.AWS)
	if err != nil {
		return exitError(fmt.Sprintf("couldn't get instances of swarm: %s", swarmName), err)
	}

	instances, err := s.GetInstances()
	if err != nil {
		return exitError(fmt.Sprintf("couldn't get instances of swarm: %s", swarmName), err)
	}

	lines := []string{instancesHeader}
	for _, i := range instances {
		lines = append(lines, fmt.Sprintf(instancesScheme, i.Id, i.Image, i.Type, i.PublicDNSName, i.PrivateDNSName))
	}
	fmt.Println(columnize.SimpleFormat(lines))
	return 0
}

// SealStatus shows the seal status of the vault
func (s *VaultService) SealStatus() error {
	m := sync.Mutex{}
	lines := []string{
		"Address | Status | Key Threshold | Key Shares | Unseal Progress",
	}
	seal := func(client VaultClient) error {
		s.log.Debugf("Fetching seal status of vault at %s", client.Address)
		status, err := client.Client.Sys().SealStatus()
		var line string
		if err != nil {
			line = fmt.Sprintf("%s | error: %s | - | - | -", client.Address, err.Error())
		} else {
			statusText := "unsealed"
			if status.Sealed {
				statusText = "sealed"
			}
			line = fmt.Sprintf("%s | %s | %d | %d | %d", client.Address, statusText, status.T, status.N, status.Progress)
		}
		m.Lock()
		defer m.Unlock()
		lines = append(lines, line)
		return nil
	}
	if err := s.asyncForEachClient(seal); err != nil {
		return maskAny(err)
	}
	fmt.Println(columnize.SimpleFormat(lines))
	return nil
}

func (this *Clusters) printSummary(zkzone *zk.ZkZone, clusterPattern string, port string) {
	lines := []string{"Zone|Cluster|Brokers|Topics|Partitions|FlatMsg|Cum"}

	type summary struct {
		zone, cluster               string
		brokers, topics, partitions int
		flat, cum                   int64
	}
	summaries := make([]summary, 0, 10)
	zkzone.ForSortedClusters(func(zkcluster *zk.ZkCluster) {
		if !patternMatched(zkcluster.Name(), clusterPattern) {
			return
		}

		brokers, topics, partitions, flat, cum := this.clusterSummary(zkcluster)
		summaries = append(summaries, summary{zkzone.Name(), zkcluster.Name(), brokers, topics, partitions,
			flat, cum})

	})
	sortutil.DescByField(summaries, "cum")
	var totalFlat, totalCum int64
	for _, s := range summaries {
		lines = append(lines, fmt.Sprintf("%s|%s|%d|%d|%d|%s|%s",
			s.zone, s.cluster, s.brokers, s.topics, s.partitions,
			gofmt.Comma(s.flat), gofmt.Comma(s.cum)))

		totalCum += s.cum
		totalFlat += s.flat
	}
	this.Ui.Output(columnize.SimpleFormat(lines))
	this.Ui.Output(fmt.Sprintf("Flat:%s Cum:%s", gofmt.Comma(totalFlat), gofmt.Comma(totalCum)))
}

func statusRun(cmd *cobra.Command, args []string) {
	if len(args) != 1 {
		fmt.Println("Serial missing")
		os.Exit(1)
	}

	configDir, err := homedir.Expand(globalFlags.config)
	assert(err)

	machine, err := vm.Load(configDir, args[0])
	assert(err)

	status, err := machine.Status(statusFlags.TMuxSessionName)
	assert(err)

	var hds, nics []string
	for _, hd := range machine.HDs {
		hds = append(hds, fmt.Sprintf("%s %s", hd.Device, hd.Size))
	}
	for _, nic := range machine.NICs {
		nics = append(nics, fmt.Sprintf("%s %s", nic.Bridge, nic.Mac))
	}

	lines := []string{}
	lines = append(lines, fmt.Sprintf(statusScheme, "Serial:", machine.Serial))
	lines = append(lines, fmt.Sprintf(statusScheme, "Status:", status))
	lines = append(lines, fmt.Sprintf(statusScheme, "Image:", machine.Image))
	lines = append(lines, fmt.Sprintf("%s | %d", "Memory:", machine.Memory))
	lines = append(lines, fmt.Sprintf(statusScheme, "HDs:", strings.Join(hds, ",")))
	lines = append(lines, fmt.Sprintf(statusScheme, "NICs:", strings.Join(nics, ",")))
	fmt.Println(columnize.SimpleFormat(lines))
}

func printAllocations(mesos *lib.Mesos) int {
	output := make([]string, 1)
	output[0] = "Hostname | Cpu % | Cpu Ratio | Mem % | Mem Ratio | Disk % | Disk Ratio"

	for _, s := range mesos.Cluster.Slaves {
		ss := s.Stats
		ln := fmt.Sprintf(
			"%s | %.0f | %.1f/%d | %.0f | %d/%d | %.0f| %d/%d",
			s.HostName,
			ss.CpusPercent*100,
			ss.CpusUsed,
			ss.CpusTotal,
			ss.MemPercent*100,
			ss.MemUsed,
			ss.MemTotal,
			ss.DiskPercent*100,
			ss.DiskUsed,
			ss.DiskTotal,
		)
		output = append(output, ln)
	}

	result := columnize.SimpleFormat(output)
	fmt.Println(result)
	return 0
}

func listRun(cmd *cobra.Command, args []string) {
	if listFlags.Fields == "" {
		fmt.Printf("Invalid fields parameter. Please choose valid fields: %s\n", strings.Join(hostToFieldKeys(listFields), ","))
		os.Exit(1)
	}

	cols := strings.Split(listFlags.Fields, ",")
	for _, s := range cols {
		if _, ok := listFields[s]; !ok {
			fmt.Printf("Invalid field: %q.\n\nUsage: %s\n", s, cmd.Usage())
			os.Exit(1)
		}
	}

	hosts, err := mayu.List()
	assert(err)

	lines := []string{}
	for _, host := range hosts {
		var f []string
		for _, c := range cols {
			f = append(f, listFields[c](&host))
		}
		lines = append(lines, strings.Join(f, "|"))
	}
	sort.Strings(lines)

	if !listFlags.NoLegend {
		lines = append([]string{strings.ToUpper(strings.Join(cols, "|"))}, lines...)
	}

	fmt.Println(columnize.SimpleFormat(lines))
}

func AppList(configStore *config.Store, env string) error {

	envs := []string{env}

	if env == "" {
		var err error
		envs, err = configStore.ListEnvs()
		if err != nil {
			return err
		}
	}

	columns := []string{"NAME | ENV | VERSION | IMAGE ID | CONFIG | POOLS "}

	for _, env := range envs {

		appList, err := configStore.ListApps(env)
		if err != nil {
			return err
		}

		pools, err := configStore.ListPools(env)
		if err != nil {
			return err
		}

		for _, app := range appList {
			name := app.Name()
			versionDeployed := app.Version()
			versionID := app.VersionID()
			if len(versionID) > 12 {
				versionID = versionID[:12]
			}

			assignments := []string{}
			for _, pool := range pools {
				aa, err := configStore.ListAssignments(env, pool)
				if err != nil {
					return err
				}
				if utils.StringInSlice(app.Name(), aa) {
					assignments = append(assignments, pool)
				}
			}

			columns = append(columns, strings.Join([]string{
				name,
				env,
				versionDeployed,
				versionID,
				strconv.FormatInt(app.ID(), 10),
				strings.Join(assignments, ","),
			}, " | "))
		}
	}
	output := columnize.SimpleFormat(columns)
	fmt.Println(output)
	return nil
}