// Executes the "list" command
func execListCommand(c *cli.Context) error {
klient := newEtcdMinionClientFromFlags(c)
cFlag := c.String("with-classifier")
minions, err := parseClassifierPattern(klient, cFlag)
// Ignore errors about missing minion directory
if err != nil {
if eerr, ok := err.(client.Error); !ok || eerr.Code != client.ErrorCodeKeyNotFound {
return cli.NewExitError(err.Error(), 1)
}
}
if len(minions) == 0 {
return nil
}
table := uitable.New()
table.MaxColWidth = 80
table.AddRow("MINION", "NAME")
for _, minion := range minions {
name, err := klient.MinionName(minion)
if err != nil {
return cli.NewExitError(err.Error(), 1)
}
table.AddRow(minion, name)
}
fmt.Println(table)
return nil
}
// Executes the "lastseen" command
func execLastseenCommand(c *cli.Context) error {
client := newEtcdMinionClientFromFlags(c)
cFlag := c.String("with-classifier")
minions, err := parseClassifierPattern(client, cFlag)
if err != nil {
return cli.NewExitError(err.Error(), 1)
}
table := uitable.New()
table.MaxColWidth = 80
table.AddRow("MINION", "LASTSEEN")
for _, minion := range minions {
lastseen, err := client.MinionLastseen(minion)
if err != nil {
return cli.NewExitError(err.Error(), 1)
}
table.AddRow(minion, time.Unix(lastseen, 0))
}
fmt.Println(table)
return nil
}
func cmdListFull(s *StoreChan) error {
lst, err := s.ListFull()
if err != nil {
return fmt.Errorf("Error listing user: %s\n", err)
}
var keys []string
for k := range lst {
keys = append(keys, k)
}
sort.Strings(keys)
table := uitable.New()
table.MaxColWidth = 80
table.AddRow("NAME", "TYPE", "LAST-CHANGED", "VALID", "SUPPORTED", "FORMAT", "PARAMS")
for _, k := range keys {
t := "user"
if lst[k].IsAdmin {
t = "admin"
}
table.AddRow(k, t, lst[k].LastChanged.String(), lst[k].IsValid, lst[k].IsSupported, lst[k].FormatID, lst[k].FormatParams)
}
fmt.Println(table)
return nil
}
func cmdListSupported(s *StoreChan) error {
lst, err := s.List()
if err != nil {
return fmt.Errorf("Error listing user: %s\n", err)
}
var keys []string
for k := range lst {
keys = append(keys, k)
}
sort.Strings(keys)
table := uitable.New()
table.MaxColWidth = 50
table.AddRow("NAME", "TYPE", "LAST-CHANGED")
for _, k := range keys {
t := "user"
if lst[k].IsAdmin {
t = "admin"
}
table.AddRow(k, t, lst[k].LastChanged.String())
}
fmt.Println(table)
return nil
}
// Executes the "queue" command
func execQueueCommand(c *cli.Context) {
if len(c.Args()) == 0 {
displayError(errMissingMinion, 64)
}
minion := uuid.Parse(c.Args()[0])
if minion == nil {
displayError(errInvalidUUID, 64)
}
client := newEtcdMinionClientFromFlags(c)
// Ignore errors about missing queue directory
queue, err := client.MinionTaskQueue(minion)
if err != nil {
if eerr, ok := err.(etcdclient.Error); !ok || eerr.Code != etcdclient.ErrorCodeKeyNotFound {
displayError(err, 1)
}
}
if len(queue) == 0 {
return
}
table := uitable.New()
table.MaxColWidth = 40
table.AddRow("TASK", "COMMAND", "STATE", "TIME")
for _, task := range queue {
table.AddRow(task.TaskID, task.Command, task.State, time.Unix(task.TimeReceived, 0))
}
fmt.Println(table)
}
// Executes the "queue" command
func execQueueCommand(c *cli.Context) error {
if len(c.Args()) == 0 {
return cli.NewExitError(errNoMinion.Error(), 64)
}
minion := uuid.Parse(c.Args()[0])
if minion == nil {
return cli.NewExitError(errInvalidUUID.Error(), 64)
}
klient := newEtcdMinionClientFromFlags(c)
// Ignore errors about missing queue directory
queue, err := klient.MinionTaskQueue(minion)
if err != nil {
if eerr, ok := err.(client.Error); !ok || eerr.Code != client.ErrorCodeKeyNotFound {
return cli.NewExitError(err.Error(), 1)
}
}
if len(queue) == 0 {
return nil
}
table := uitable.New()
table.MaxColWidth = 40
table.AddRow("TASK", "STATE", "RECEIVED")
for _, t := range queue {
table.AddRow(t.ID, t.State, time.Unix(t.TimeReceived, 0))
}
fmt.Println(table)
return nil
}
// Executes the "info" command
func execInfoCommand(c *cli.Context) error {
if len(c.Args()) == 0 {
return cli.NewExitError(errNoMinion.Error(), 64)
}
arg := c.Args()[0]
minion := uuid.Parse(arg)
if minion == nil {
return cli.NewExitError(errInvalidUUID.Error(), 64)
}
klient := newEtcdMinionClientFromFlags(c)
name, err := klient.MinionName(minion)
if err != nil {
return cli.NewExitError(err.Error(), 1)
}
lastseen, err := klient.MinionLastseen(minion)
if err != nil {
return cli.NewExitError(err.Error(), 1)
}
// Ignore errors about missing queue directory
taskQueue, err := klient.MinionTaskQueue(minion)
if err != nil {
if eerr, ok := err.(client.Error); !ok || eerr.Code != client.ErrorCodeKeyNotFound {
return cli.NewExitError(err.Error(), 1)
}
}
// Ignore errors about missing log directory
taskLog, err := klient.MinionTaskLog(minion)
if err != nil {
if eerr, ok := err.(client.Error); !ok || eerr.Code != client.ErrorCodeKeyNotFound {
return cli.NewExitError(err.Error(), 1)
}
}
// Ignore errors about missing classifier directory
classifierKeys, err := klient.MinionClassifierKeys(minion)
if err != nil {
if eerr, ok := err.(client.Error); !ok || eerr.Code != client.ErrorCodeKeyNotFound {
return cli.NewExitError(err.Error(), 1)
}
}
table := uitable.New()
table.MaxColWidth = 80
table.AddRow("Minion:", minion)
table.AddRow("Name:", name)
table.AddRow("Lastseen:", time.Unix(lastseen, 0))
table.AddRow("Queue:", len(taskQueue))
table.AddRow("Log:", len(taskLog))
table.AddRow("Classifiers:", len(classifierKeys))
fmt.Println(table)
return nil
}
func displayMap(writer io.Writer, props map[string]interface{}) {
table := uitable.New()
for key, value := range props {
table.AddRow("", labelUI(key), value)
}
fmt.Fprintln(writer, table)
fmt.Fprintln(writer)
}
// Print out the steps inline.
func Build() string {
table := uitable.New()
table.MaxColWidth = 50
for _, s := range steps {
table.AddRow(s, s.Complete)
}
return table.String()
}
// printRequirements prints all of the requirements in the yaml file.
func (l *dependencyListCmd) printRequirements(reqs *chartutil.Requirements, out io.Writer) {
table := uitable.New()
table.MaxColWidth = 80
table.AddRow("NAME", "VERSION", "REPOSITORY", "STATUS")
for _, row := range reqs.Dependencies {
table.AddRow(row.Name, row.Version, row.Repository, l.dependencyStatus(row))
}
fmt.Fprintln(out, table)
}
func repaint(w *uilive.Writer, logCounters []*LogCounter, totalLinesRead int) {
table := uitable.New()
table.AddRow("PATTERN", "COUNT", "RATE/s", "RATE/m", "RATE/hr")
for _, c := range logCounters {
table.AddRow(c.p.String(), c.c.Value(), c.rsec.String(), c.rmin.String(), c.rhr.String())
}
table.AddRow("Total Lines Read:", totalLinesRead, "--", "--", "--")
fmt.Fprintln(w, table)
w.Flush()
}
func (s *searchCmd) formatSearchResults(res []*search.Result) string {
if len(res) == 0 {
return "No results found"
}
table := uitable.New()
table.MaxColWidth = 50
table.AddRow("NAME", "VERSION", "DESCRIPTION")
for _, r := range res {
table.AddRow(r.Name, r.Chart.Version, r.Chart.Description)
}
return table.String()
}
// ToPlainTextSummary format summary for plain text.
func ToPlainTextSummary(r models.ScanResult) string {
stable := uitable.New()
stable.MaxColWidth = 84
stable.Wrap = true
cves := r.KnownCves
if !config.Conf.IgnoreUnscoredCves {
cves = append(cves, r.UnknownCves...)
}
for _, d := range cves {
var scols []string
switch {
case config.Conf.Lang == "ja" &&
0 < d.CveDetail.Jvn.CvssScore():
summary := d.CveDetail.Jvn.CveTitle()
scols = []string{
d.CveDetail.CveID,
fmt.Sprintf("%-4.1f (%s)",
d.CveDetail.CvssScore(config.Conf.Lang),
d.CveDetail.Jvn.CvssSeverity(),
),
summary,
}
case 0 < d.CveDetail.CvssScore("en"):
summary := d.CveDetail.Nvd.CveSummary()
scols = []string{
d.CveDetail.CveID,
fmt.Sprintf("%-4.1f (%s)",
d.CveDetail.CvssScore(config.Conf.Lang),
d.CveDetail.Nvd.CvssSeverity(),
),
summary,
}
default:
scols = []string{
d.CveDetail.CveID,
"?",
d.CveDetail.Nvd.CveSummary(),
}
}
cols := make([]interface{}, len(scols))
for i := range cols {
cols[i] = scols[i]
}
stable.AddRow(cols...)
}
return fmt.Sprintf("%s", stable)
}
func formatList(rels []*release.Release) string {
table := uitable.New()
table.MaxColWidth = 30
table.AddRow("NAME", "REVISION", "UPDATED", "STATUS", "CHART")
for _, r := range rels {
c := fmt.Sprintf("%s-%s", r.Chart.Metadata.Name, r.Chart.Metadata.Version)
t := timeconv.String(r.Info.LastDeployed)
s := r.Info.Status.Code.String()
v := r.Version
table.AddRow(r.Name, v, t, s, c)
}
return table.String()
}
func formatTabular(metrics ...metric) string {
table := uitable.New()
table.MaxColWidth = 50
table.Wrap = true
for _, col := range []int{1, 2, 3, 4} {
table.RightAlign(col)
}
table.AddRow("UNIT", "TIMESTAMP", "METRIC", "VALUE")
for _, m := range metrics {
table.AddRow(m.Unit, m.Timestamp.Format(time.RFC3339), m.Metric, m.Value)
}
return table.String() + "\n"
}
func toOneLineSummary(rs ...models.ScanResult) string {
table := uitable.New()
table.MaxColWidth = maxColWidth
table.Wrap = true
for _, r := range rs {
cols := []interface{}{
r.FormatServerName(),
r.CveSummary(),
r.Packages.ToUpdatablePacksSummary(),
}
table.AddRow(cols...)
}
return fmt.Sprintf("%s\n", table)
}
func formatHistory(rls []*release.Release) string {
tbl := uitable.New()
tbl.MaxColWidth = 30
tbl.AddRow("REVISION", "UPDATED", "STATUS", "CHART")
for i := len(rls) - 1; i >= 0; i-- {
r := rls[i]
c := formatChartname(r.Chart)
t := timeconv.String(r.Info.LastDeployed)
s := r.Info.Status.Code.String()
v := r.Version
tbl.AddRow(v, t, s, c)
}
return tbl.String()
}
func Example() {
table := uitable.New()
table.MaxColWidth = 50
fmt.Println("==> List")
table.AddRow("NAME", "BIRTHDAY", "BIO")
for _, hacker := range hackers {
table.AddRow(hacker.Name, hacker.Birthday, hacker.Bio)
}
fmt.Println(table)
fmt.Print("\n==> Details\n")
table = uitable.New()
table.MaxColWidth = 80
table.Wrap = true
for _, hacker := range hackers {
table.AddRow("Name:", hacker.Name)
table.AddRow("Birthday:", hacker.Birthday)
table.AddRow("Bio:", hacker.Bio)
table.AddRow("") // blank
}
fmt.Println(table)
}
func toScanSummary(rs ...models.ScanResult) string {
table := uitable.New()
table.MaxColWidth = maxColWidth
table.Wrap = true
for _, r := range rs {
cols := []interface{}{
r.FormatServerName(),
fmt.Sprintf("%s%s", r.Family, r.Release),
fmt.Sprintf("%d CVEs", len(r.ScannedCves)),
r.Packages.ToUpdatablePacksSummary(),
}
table.AddRow(cols...)
}
return fmt.Sprintf("%s\n", table)
}
func runRepoList(cmd *cobra.Command, args []string) error {
f, err := repo.LoadRepositoriesFile(repositoriesFile())
if err != nil {
return err
}
if len(f.Repositories) == 0 {
return errors.New("no repositories to show")
}
table := uitable.New()
table.MaxColWidth = 50
table.AddRow("NAME", "URL")
for k, v := range f.Repositories {
table.AddRow(k, v)
}
fmt.Println(table)
return nil
}
// formatTabular returns a tabular summary of available plans.
func formatTabular(writer io.Writer, value interface{}) error {
plans, ok := value.([]plan)
if !ok {
return errors.Errorf("expected value of type %T, got %T", plans, value)
}
table := uitable.New()
table.MaxColWidth = 50
table.Wrap = true
table.AddRow("Plan", "Price", "Description")
for _, plan := range plans {
table.AddRow(plan.URL, plan.Price, plan.Description)
}
fmt.Fprint(writer, table)
return nil
}
// formatTabular returns a tabular summary of available plans.
func formatTabular(value interface{}) ([]byte, error) {
plans, ok := value.([]plan)
if !ok {
return nil, errors.Errorf("expected value of type %T, got %T", plans, value)
}
table := uitable.New()
table.MaxColWidth = 50
table.Wrap = true
table.AddRow("PLAN", "PRICE", "DESCRIPTION")
for _, plan := range plans {
table.AddRow(plan.URL, plan.Price, plan.Description)
}
return []byte(table.String()), nil
}
func (a *repoListCmd) run() error {
f, err := repo.LoadRepositoriesFile(a.home.RepositoryFile())
if err != nil {
return err
}
if len(f.Repositories) == 0 {
return errors.New("no repositories to show")
}
table := uitable.New()
table.MaxColWidth = 50
table.AddRow("NAME", "URL")
for _, re := range f.Repositories {
table.AddRow(re.Name, re.URL)
}
fmt.Fprintln(a.out, table)
return nil
}
func (a *repoListCmd) run() error {
f, err := repo.LoadRepositoriesFile(repositoriesFile())
if err != nil {
return err
}
if len(f.Repositories) == 0 {
return errors.New("no repositories to show")
}
table := uitable.New()
table.MaxColWidth = 50
table.AddRow("NAME", "URL")
for k, v := range f.Repositories {
table.AddRow(k, v)
}
fmt.Println(table)
return nil
}
// ShowStatus cli status
func ShowStatus(entryPoint string) {
parts := strings.SplitN(entryPoint, "://", 2)
c, err := net.Dial(parts[0], parts[1])
if err != nil {
log.Fatal(err)
}
conn := protocol.NewClientConn(c)
defer conn.Close()
err = conn.Send(protocol.TYPECLIENT.Bytes())
if err != nil {
log.Fatal(err)
}
var msgID = []byte("100")
buf := bytes.NewBuffer(nil)
buf.Write(msgID)
buf.Write(protocol.NullChar)
buf.Write(protocol.STATUS.Bytes())
err = conn.Send(buf.Bytes())
if err != nil {
log.Fatal(err)
}
payload, err := conn.Receive()
if err != nil {
log.Fatal(err)
}
_parts := bytes.SplitN(payload, protocol.NullChar, 2)
if len(_parts) != 2 {
err := fmt.Sprint("ParseCommand InvalID %v\n", payload)
panic(err)
}
stats := strings.Split(string(_parts[1]), "\n")
sort.Strings(stats)
table := uitable.New()
table.MaxColWidth = 50
table.AddRow("FUNCTION", "WORKERS", "JOBS", "PROCESSING")
for _, stat := range stats {
if stat == "" {
continue
}
line := strings.Split(stat, ",")
table.AddRow(line[0], line[1], line[2], line[3])
}
fmt.Println(table)
}
func displayTasks(trackers map[string][]tracker.Task) {
table := uitable.New()
table.AddRow("ID", "TRACKER", "TASK")
if len(trackers) > 0 {
var t []string
for trackr := range trackers {
t = append(t, trackr)
}
sort.Strings(t)
for _, i := range t {
for _, task := range trackers[i] {
table.AddRow(task.ID, i, task.Title)
}
}
fmt.Println(table)
} else {
println("No open tasks.")
}
}
func toPlainTextUnknownCve(cveInfo models.CveInfo, osFamily string) string {
cveID := cveInfo.CveDetail.CveID
dtable := uitable.New()
dtable.MaxColWidth = 100
dtable.Wrap = true
dtable.AddRow(cveID)
dtable.AddRow("-------------")
dtable.AddRow("Score", "?")
dtable.AddRow("NVD",
fmt.Sprintf("%s?vulnId=%s", nvdBaseURL, cveID))
dtable.AddRow("CVE Details",
fmt.Sprintf("%s/%s", cveDetailsBaseURL, cveID))
dlinks := distroLinks(cveInfo, osFamily)
for _, link := range dlinks {
dtable.AddRow(link.title, link.url)
}
return fmt.Sprintf("%s", dtable)
}
// formatTabular returns a tabular view of available budgets.
func formatTabular(value interface{}) ([]byte, error) {
b, ok := value.(*wireformat.ListBudgetsResponse)
if !ok {
return nil, errors.Errorf("expected value of type %T, got %T", b, value)
}
sort.Sort(b.Budgets)
table := uitable.New()
table.MaxColWidth = 50
table.Wrap = true
table.AddRow("BUDGET", "MONTHLY", "ALLOCATED", "AVAILABLE", "SPENT")
for _, budgetEntry := range b.Budgets {
table.AddRow(budgetEntry.Budget, budgetEntry.Limit, budgetEntry.Allocated, budgetEntry.Available, budgetEntry.Consumed)
}
table.AddRow("TOTAL", b.Total.Limit, b.Total.Allocated, b.Total.Available, b.Total.Consumed)
table.AddRow("", "", "", "", "")
table.AddRow("Credit limit:", b.Credit, "", "", "")
return []byte(table.String()), nil
}
// Pretty is a pretty print of a chain
func (c *Chain) Pretty() {
ks := c.Keys()
sort.Strings(ks)
fmt.Fprintf(os.Stdout, "--------------\n")
table := uitable.New()
table.MaxColWidth = 50
table.Separator = "|"
table.AddRow("Index", "Prefix key", "Available choices")
for i, x := range ks {
table.AddRow(
fmt.Sprintf("\033[0;37m %03d \033[0m", i),
fmt.Sprintf("\033[0;32m %s \033[0m", x),
fmt.Sprintf("\033[0;33m %s \033[0m", c.chain[x]))
}
fmt.Fprintf(os.Stdout, table.String())
fmt.Fprintf(os.Stdout, "\n--------------\n")
}
func toPlainTextDetailsLangJa(cveInfo models.CveInfo, osFamily string) string {
cveDetail := cveInfo.CveDetail
cveID := cveDetail.CveID
jvn := cveDetail.Jvn
dtable := uitable.New()
dtable.MaxColWidth = maxColWidth
dtable.Wrap = true
dtable.AddRow(cveID)
dtable.AddRow("-------------")
if score := cveDetail.Jvn.CvssScore(); 0 < score {
dtable.AddRow("Score",
fmt.Sprintf("%4.1f (%s)",
cveDetail.Jvn.CvssScore(),
jvn.CvssSeverity(),
))
} else {
dtable.AddRow("Score", "?")
}
dtable.AddRow("Vector", jvn.CvssVector())
dtable.AddRow("Title", jvn.CveTitle())
dtable.AddRow("Description", jvn.CveSummary())
dtable.AddRow(cveDetail.CweID(), cweURL(cveDetail.CweID()))
dtable.AddRow(cveDetail.CweID()+"(JVN)", cweJvnURL(cveDetail.CweID()))
dtable.AddRow("JVN", jvn.Link())
dtable.AddRow("NVD", fmt.Sprintf("%s?vulnId=%s", nvdBaseURL, cveID))
dtable.AddRow("MITRE", fmt.Sprintf("%s%s", mitreBaseURL, cveID))
dtable.AddRow("CVE Details", fmt.Sprintf("%s/%s", cveDetailsBaseURL, cveID))
dtable.AddRow("CVSS Claculator", cveDetail.CvssV2CalculatorLink("ja"))
dlinks := distroLinks(cveInfo, osFamily)
for _, link := range dlinks {
dtable.AddRow(link.title, link.url)
}
dtable = addPackageInfos(dtable, cveInfo.Packages)
dtable = addCpeNames(dtable, cveInfo.CpeNames)
return fmt.Sprintf("%s", dtable)
}
