コード例 #1
0
ファイル: simple_tables.go プロジェクト: vrosnet/termtable
func main() {
	fmt.Println("Simple table:")

	t := termtable.NewTable(nil, nil)
	t.SetHeader([]string{"LOWERCASE", "UPPERCASE", "NUMBERS"})
	t.AddRow([]string{"abc", "ABCD", "12345"})
	t.AddRow([]string{"defg", "EFGHI", "678"})
	t.AddRow([]string{"hijkl", "JKL", "9000"})
	fmt.Println(t.Render())

	fmt.Println("\nSimple table, alternative syntax:")

	rows := [][]string{
		[]string{"abc", "ABCD", "12345"},
		[]string{"defg", "EFGHI", "678"},
		[]string{"hijkl", "JKL", "9000"},
	}
	t = termtable.NewTable(rows, nil)
	t.SetHeader([]string{"LOWERCASE", "UPPERCASE", "NUMBERS"})
	fmt.Println(t.Render())

	fmt.Println("\nSimple table w/ separators and custom padding:")

	t = termtable.NewTable(nil, &termtable.TableOptions{
		Padding:      3,
		UseSeparator: true,
	})
	t.SetHeader([]string{"LOWERCASE", "UPPERCASE", "NUMBERS"})
	t.AddRow([]string{"abc", "ABCD", "12345"})
	t.AddRow([]string{"defg", "EFGHI", "678"})
	t.AddRow([]string{"hijkl", "JKL", "9000"})
	fmt.Println(t.Render())
}
コード例 #2
0
ファイル: sql.go プロジェクト: jmoiron/what-the-sql
func formatResults(results [][]interface{}, columns []string) string {
	rows := [][]string{}
	for _, row := range results {
		s := []string{}
		for _, res := range row {
			if res == nil {
				s = append(s, "NULL")
			} else {
				s = append(s, res.(string))
			}
		}
		rows = append(rows, s)
	}
	t := termtable.NewTable(rows, &termtable.TableOptions{Padding: 2, UseSeparator: true})
	t.SetHeader(columns)
	return t.Render()
}
コード例 #3
0
ファイル: profiles.go プロジェクト: hendrikcech/tent-cli
func CmdProfiles(c *Config) *cobra.Command {
	return &cobra.Command{
		Use:   "profiles",
		Short: "Manage entity profiles.",
		Long: `
List, add or remove profiles or change the default.
Profiles save entity uris' and credentials. They are identified by a unique name.
The default profile is used by other commands like create, query and get.`,
		Run: func(cmd *cobra.Command, args []string) {
			t := termtable.NewTable(nil, nil)
			t.SetHeader([]string{"NAME", "ENTITY", "ID", "KEY", "APP"})

			for _, p := range c.Profiles {
				t.AddRow([]string{p.Name, p.Entity, p.ID, p.Key, p.App})
			}

			fmt.Println(t.Render())
		},
	}
}
コード例 #4
0
ファイル: schemas.go プロジェクト: hendrikcech/tent-cli
func CmdSchemas(c *Config) *cobra.Command {
	return &cobra.Command{
		Use:   "schemas",
		Short: "Manage post schemas.",
		Long: `
List, set or remove post schemas.
Schemas keep you from typing post types over and over by mapping them to short names.
This simple feature might get expanded when strict post schemas get introduced with Tent 0.4.

Post types can optionally be saved with fragments (e.g. "schemas add status https://tent.io/types/status/v0#reply"). These extensions can be overwritten when used: "create status#different_fragment".
`,
		Run: func(cmd *cobra.Command, args []string) {
			t := termtable.NewTable(nil, nil)
			t.SetHeader([]string{"NAME", "POSTTYPE"})

			for _, s := range c.Schemas {
				t.AddRow([]string{s.Name, s.PostType})
			}

			fmt.Println(t.Render())
		},
	}
}
コード例 #5
0
ファイル: findilo.go プロジェクト: pepyaka/serfin
func main() {
	// arg from cmdline
	flag.Usage = func() {
		fmt.Printf("Usage: findilo [options] ww.xx.yy.zz/aa ...\n  ww.xx.yy.zz/aa - CIDR network address\n\nOptions:\n")
		flag.PrintDefaults()
	}
	flag.Parse()

	// Create ip list
	var hosts []host
	for _, argNet := range flag.Args() {
		_, subnet, err := net.ParseCIDR(argNet)
		if err != nil {
			log.Fatal(err)
		}
		ip := subnet.IP
		for subnet.Contains(ip) {
			hosts = append(hosts, host{ip: ip})
			ip = ipInc(ip)
		}
	}

	var rLimit syscall.Rlimit
	err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &rLimit)
	if err != nil {
		log.Fatal("Error Getting Rlimit ", err)
	}
	wNum := int(rLimit.Cur / 2)
	hNum := len(hosts)

	bar := pb.StartNew(hNum)
	bar.ShowTimeLeft = false

	// Create workers
	jobs := make(chan int, hNum)
	for w := 0; w < wNum; w++ {
		go httpWorker(jobs, hosts, bar)
	}

	for i := range hosts {
		wg.Add(1)
		jobs <- i
	}
	close(jobs)

	wg.Wait()

	//create table and fill it
	table := termtable.NewTable(nil, &termtable.TableOptions{
		Padding:      3,
		UseSeparator: true,
	})
	header := []string{"ip", "Model", "Serial", "iLO", "Firmware", "Build date", "Error"}
	if *verbose {
		table.SetHeader(header)
	} else {
		table.SetHeader(header[:len(header)-1])
	}
	for _, h := range hosts {
		row := []string{h.ip.String(), h.SPN, h.SBSN, h.PN, h.FWRI, h.BBLK, h.Err}
		if *verbose {
			table.AddRow(row)
		} else {
			if h.PN != "" {
				table.AddRow(row[:len(row)-1])
			}
		}
	}
	bar.Finish()
	fmt.Println(table.Render())
}
コード例 #6
0
ファイル: query.go プロジェクト: hendrikcech/tent-cli
func CmdQuery(c *Config) *cobra.Command {
	var limit int
	var since string    // 1234567890,version
	var before string   // 1234567890,version
	var until string    // 1234567890,version
	var entities string // entityone,entitytwo
	var types string    // typeone,typetwo
	var maxRefs int
	var sortBy string // r,p,vr,vp
	// var mentions string // mentionone,mentiontwo

	var profile string

	cmd := &cobra.Command{
		Use:   "query",
		Short: "Query the posts feed.",
		Long: `
Query the posts feed of the default profile.
Find more information about the available parameters here: https://tent.io/docs/api#postsfeed
Join multiple values with commata, i.e. when using --entities or --types.

A note about --types and fragments:
- "--types=https://tent.io/types/status/v0" matches all fragments
- "--types=https://tent.io/types/status/v0#" just matches "https://tent.io/types/status/v0#"
- "--types=https://tent.io/types/status/v0#reply" just matches "https://tent.io/types/status/v0#reply"
`,
		Run: func(cmd *cobra.Command, args []string) {
			p, err := c.Profile(profile)
			maybeExit(err)
			client := p.Client()

			q := tent.NewPostsFeedQuery()

			q.Limit(limit)
			q.MaxRefs(maxRefs)

			timeSetter := map[string]func(time.Time, string) *tent.PostsFeedQuery{
				since:  q.Since,
				before: q.Before,
				until:  q.Until,
			}
			for arg, setter := range timeSetter {
				err = splitAndSetTimeValue(arg, setter)
				maybeExit(err)
			}

			if entities != "" {
				entitiesStr, err := splitAndMaybeReplace(entities, func(name string) (string, error) {
					if i, p := c.ProfileByName(name); i > -1 {
						return p.Entity, nil
					}
					if !isURL(name) {
						return "", fmt.Errorf(`Profile "%v" not found.`, name)
					}
					return name, nil
				})
				maybeExit(err)
				q.Set("entities", entitiesStr)
			}
			if types != "" {
				typesStr, err := splitAndMaybeReplace(types, func(name string) (string, error) {
					if i, s := c.SchemaByName(name); i > -1 {
						return s.MergeFragment(name), nil
					}
					if !isURL(name) {
						return "", fmt.Errorf(`Schema "%v" not found.`, name)
					}
					return name, nil
				})
				maybeExit(err)
				q.Set("types", typesStr)
			}
			if sortBy != "" {
				order, err := matchSortOrder(sortBy)
				maybeExit(err)
				q.SortBy(order)
			}

			res, err := client.GetFeed(q, nil)
			maybeExit(err)

			t := termtable.NewTable(nil, nil)
			t.SetHeader([]string{"ID", "ENTITY", "TYPE", "PUBLISHED_AT"})

			for _, p := range res.Posts {
				// layout := "2006-01-02 15:04" // p.PublishedAt.Format(layout)
				pubAt := strconv.FormatInt(p.PublishedAt.UnixMillis(), 10)
				t.AddRow([]string{p.ID, p.Entity, p.Type, pubAt})
			}

			fmt.Println(t.Render())
		},
	}

	cmd.Flags().IntVarP(&limit, "limit", "l", 25, "Cap number of returned posts.")
	cmd.Flags().StringVarP(&since, "since", "s", "", "Only posts since timestamp and/or version. Format: `123456789,versionid`")
	cmd.Flags().StringVarP(&before, "before", "b", "", "Only posts before timestamp and/or version. Format: `123456789,versionid`")
	cmd.Flags().StringVarP(&until, "until", "u", "", "Only posts until timestamp and/or version. Format: `123456789,versionid`")
	cmd.Flags().StringVarP(&entities, "entities", "e", "", "Only posts from specific entities.")
	cmd.Flags().StringVarP(&types, "types", "t", "", "Only posts with specific types.")
	cmd.Flags().IntVarP(&maxRefs, "maxrefs", "r", 5, "Cap number of inlined refs per post.")
	cmd.Flags().StringVarP(&sortBy, "sortBy", "o", "", `Define sort order. Possible values: "p" published_at, "r" received_at, "vp" version.published_at, "vr" version.received_at`)
	// cmd.Flags().StringVarP(&mentions, "mentions", "m", "", "Only posts which mention specific entities.")

	setUseFlag(&profile, cmd)

	return cmd
}
コード例 #7
0
ファイル: archstatus.go プロジェクト: prinsmike/archstatus
func main() {

	services := []string{
		"cronie.service",
		"httpd.service",
		"mysqld.service",
		"ntpd.service",
		"postfix.service",
		"sshd.service",
		"home.mount",
		"mnt-extra.mount",
		"tmp.mount",
		"var-lib-mysqltmp.mount",
		"var.mount",
	}

	t := termtable.NewTable(nil, nil)
	t.SetHeader([]string{"SERVICE", "STATUS"})

	for _, service := range services {

		// The systemctl command.
		syscommand := exec.Command("systemctl", "status", service)

		// The grep command.
		grepcommand := exec.Command("grep", "Active:")

		// Pipe the stdout of syscommand to the stdin of grepcommand.
		grepcommand.Stdin, _ = syscommand.StdoutPipe()

		// Create a buffer of bytes.
		var b bytes.Buffer

		// Assign the address of our buffer to grepcommand.Stdout.
		grepcommand.Stdout = &b

		// Start grepcommand.
		_ = grepcommand.Start()

		// Run syscommand
		_ = syscommand.Run()

		// Wait for grepcommand to exit.
		_ = grepcommand.Wait()

		s := fmt.Sprintf("%s", &b)

		if strings.Contains(s, "active (running)") || strings.Contains(s, "active (mounted)") {
			color := ansi.ColorCode("green+h:black")
			reset := ansi.ColorCode("reset")

			t.AddRow([]string{fmtString(color, service, reset), fmtString(color, s, reset)})
		} else {
			color := ansi.ColorCode("red+h:black")
			reset := ansi.ColorCode("reset")

			t.AddRow([]string{fmtString(color, service, reset), fmtString(color, s, reset)})
		}
	}
	fmt.Println(t.Render())
}
コード例 #8
0
ファイル: simple_tables.go プロジェクト: imdario/termtable
func main() {
	fmt.Println("Simple table:")

	t := termtable.NewTable(nil, nil)
	t.SetHeader([]string{"LOWERCASE", "UPPERCASE", "NUMBERS"})
	t.AddRow([]string{"abc", "ABCD", "12345"})
	t.AddRow([]string{"defg", "EFGHI", "678"})
	t.AddRow([]string{"hijkl", "JKL", "9000"})
	fmt.Println(t.Render())

	fmt.Println("\nSimple table, alternative syntax:")

	rows := [][]string{
		[]string{"abc", "ABCD", "12345"},
		[]string{"defg", "EFGHI", "678"},
		[]string{"hijkl", "JKL", "9000"},
	}
	t = termtable.NewTable(rows, nil)
	t.SetHeader([]string{"LOWERCASE", "UPPERCASE", "NUMBERS"})
	fmt.Println(t.Render())

	fmt.Println("\nSimple table w/ separators and custom padding:")

	t = termtable.NewTable(nil, &termtable.TableOptions{
		Padding:      3,
		UseSeparator: true,
	})
	t.SetHeader([]string{"LOWERCASE", "UPPERCASE", "NUMBERS"})
	t.AddRow([]string{"abc", "ABCD", "12345"})
	t.AddRow([]string{"defg", "EFGHI", "678"})
	t.AddRow([]string{"hijkl", "JKL", "9000"})
	fmt.Println(t.Render())

	fmt.Println("\nSimple table w/ seperators, custom padding, and dynamic rows:")

	t = termtable.NewTable(nil, &termtable.TableOptions{
		Padding:      3,
		UseSeparator: true,
	})
	t.SetHeader([]string{"LOWERCASE", "UPPERCASE", "NUMBERS"})
	t.AddRow([]string{"abc", "ABCD", "12345"})
	t.AddRow([]string{"defg", "EFGHI", "678"})
	t.AddRow([]string{"hijkl", "JKL", "9000"})
	fmt.Println(t.Render())
	t.AddRow([]string{"mnop", "MNO", "479108"})
	fmt.Println(t.RenderDynamic())

	fmt.Println("\nSimple table w/ seperators, custom padding, dynamic rows, and column wrapping:")

	t = termtable.NewTable(nil, &termtable.TableOptions{
		Padding:      3,
		UseSeparator: true,
	})
	t.SetHeader([]string{"LOWERCASE", "UPPERCASE", "NUMBERS"})
	t.AddRow([]string{"abc", "ABCD", "12345"})
	t.AddRow([]string{"defg", "EFGHI", "678"})
	t.AddRow([]string{"hijkl", "JKL", "9000"})
	fmt.Println(t.Render())
	t.AddRow([]string{"mnop", "MASDADADNO", "47910987978"})
	t.AddRow([]string{"qrstuvwxyz", "QRS", "54234"})
	fmt.Println(t.RenderDynamic())
}