client

Documentation

Index

• Variables
• func Execute()
• func NewHermesV1Client() (*gophercloud.ServiceClient, error)

Variables

var AttributesCmd = &cobra.Command{
	Use:       fmt.Sprintf("attributes %s", strings.Join(validArgs, "|")),
	Args:      validateAll(cobra.ExactArgs(1), cobra.OnlyValidArgs),
	ValidArgs: validArgs,
	Short:     "List Hermes attributes",
	PreRunE: func(cmd *cobra.Command, args []string) error {
		if err := viper.BindPFlags(cmd.Flags()); err != nil {
			return err
		}

		return verifyGlobalFlags(nil)
	},
	RunE: func(cmd *cobra.Command, args []string) error {

		client, err := NewHermesV1Client()
		if err != nil {
			return fmt.Errorf("failed to create Hermes client: %s", err)
		}

		format := viper.GetString("format")

		projectID := viper.GetString("project-id")
		if viper.GetBool("all-projects") {
			projectID = "*"
		}

		listOpts := attributes.ListOpts{
			Limit:     viper.GetInt("limit"),
			MaxDepth:  viper.GetInt("max-depth"),
			ProjectID: projectID,
		}

		var allAttributes []string

		for _, name := range args {
			err = attributes.List(client, name, listOpts).EachPage(func(page pagination.Page) (bool, error) {
				attrs, err := attributes.ExtractAttributes(page)
				if err != nil {
					return false, fmt.Errorf("failed to extract attributes: %s", err)
				}

				allAttributes = append(allAttributes, attrs...)

				return true, nil
			})
			if err != nil {
				if _, ok := err.(gophercloud.ErrDefault500); ok {
					return fmt.Errorf(`failed to list attributes: %s: please try to decrease an amount of the attributes in output, e.g. set "--limit 100"`, err)
				}
				return fmt.Errorf("failed to list attributes: %s", err)
			}
		}

		switch format {
		case "json":
			jsonAttrs, err := json.MarshalIndent(allAttributes, "", "  ")
			if err != nil {
				return err
			}
			fmt.Printf("%s\n", jsonAttrs)
		case "yaml":
			yamlAttrs, err := yaml.Marshal(allAttributes)
			if err != nil {
				return err
			}
			fmt.Printf("%s", yamlAttrs)
		case "csv", "value", "table":
			fmt.Printf("%s\n", strings.Join(allAttributes, "\n"))
		default:
			return fmt.Errorf("unsupported format: %s", format)
		}

		return nil
	},
}

AttributesCmd represents the list command

var ListCmd = &cobra.Command{
	Use:   "list",
	Args:  cobra.ExactArgs(0),
	Short: "List Hermes events",
	PreRunE: func(cmd *cobra.Command, args []string) error {
		if err := viper.BindPFlags(cmd.Flags()); err != nil {
			return err
		}

		teq := viper.GetString("time")
		tgt := viper.GetString("time-start")
		tlt := viper.GetString("time-end")
		if teq != "" && !(tgt == "" && tlt == "") {
			return fmt.Errorf("cannot combine time flag with time-start or time-end flags")
		}

		return verifyGlobalFlags(defaultListKeyOrder)
	},
	RunE: func(cmd *cobra.Command, args []string) error {

		userLimit := viper.GetInt("limit")
		keyOrder := viper.GetStringSlice("column")
		if len(keyOrder) == 0 {
			keyOrder = defaultListKeyOrder
		}
		format := viper.GetString("format")

		projectID := viper.GetString("project-id")
		if viper.GetBool("all-projects") {
			projectID = "*"
		}

		listOpts := events.ListOpts{
			Limit:         maxOffset,
			TargetType:    viper.GetString("target-type"),
			TargetID:      viper.GetString("target-id"),
			InitiatorID:   viper.GetString("initiator-id"),
			InitiatorName: viper.GetString("initiator-name"),
			Action:        viper.GetString("action"),
			Outcome:       viper.GetString("outcome"),
			RequestPath:   viper.GetString("request-path"),
			ObserverType:  viper.GetString("source"),
			Search:        viper.GetString("search"),
			ProjectID:     projectID,
			Sort:          strings.Join(viper.GetStringSlice("sort"), ","),
		}

		if userLimit > 0 && userLimit <= maxOffset {

			listOpts.Limit = userLimit
		}

		if t := viper.GetString("time"); t != "" {
			rt, err := parseTime(t)
			if err != nil {
				return fmt.Errorf("failed to parse time: %s", err)
			}
			listOpts.Time = []events.DateQuery{
				{
					Date: rt,
				},
			}
		}
		if t := viper.GetString("time-start"); t != "" {
			rt, err := parseTime(t)
			if err != nil {
				return fmt.Errorf("failed to parse time-start: %s", err)
			}
			listOpts.Time = append(listOpts.Time, events.DateQuery{
				Date:   rt,
				Filter: events.DateFilterGTE,
			})
		}
		if t := viper.GetString("time-end"); t != "" {
			rt, err := parseTime(t)
			if err != nil {
				return fmt.Errorf("failed to parse time-end: %s", err)
			}
			listOpts.Time = append(listOpts.Time, events.DateQuery{
				Date:   rt,
				Filter: events.DateFilterLTE,
			})
		}

		client, err := NewHermesV1Client()
		if err != nil {
			return fmt.Errorf("failed to create Hermes client: %s", err)
		}

		var allEvents []events.Event
		var bar *pb.ProgressBar

		if err = getEvents(client, &allEvents, listOpts, userLimit, viper.GetBool("over-10k-fix"), &bar); err != nil {
			if bar != nil {
				bar.Finish()
			}
			return fmt.Errorf("failed to list the events: %s", err)
		}
		if bar != nil {
			bar.Finish()
		}

		if format == "table" {
			var buf bytes.Buffer
			table := tablewriter.NewWriter(&buf)
			table.SetColWidth(20)
			table.SetAlignment(3)
			table.SetHeader(keyOrder)

			for _, v := range allEvents {
				kv := eventToKV(v)
				tableRow := []string{}
				for _, k := range keyOrder {
					v := kv[k]
					tableRow = append(tableRow, v)
				}
				table.Append(tableRow)
			}

			table.Render()

			fmt.Print(buf.String())
		} else {
			return printEvent(allEvents, format, keyOrder)
		}

		return nil
	},
}

ListCmd represents the list command

var RootCmd = &cobra.Command{
	Use:          "hermescli",
	Short:        "Hermes CLI tool",
	SilenceUsage: true,
}

RootCmd represents the base command when called without any subcommands

var ShowCmd = &cobra.Command{
	Use:   "show <event-id> [<event-id>...]",
	Args:  cobra.MinimumNArgs(1),
	Short: "Show Hermes event",
	PreRunE: func(cmd *cobra.Command, args []string) error {
		if err := viper.BindPFlags(cmd.Flags()); err != nil {
			return err
		}

		return verifyGlobalFlags(defaultShowKeyOrder)
	},
	RunE: func(cmd *cobra.Command, args []string) error {

		client, err := NewHermesV1Client()
		if err != nil {
			return fmt.Errorf("failed to create Hermes client: %s", err)
		}

		keyOrder := viper.GetStringSlice("column")
		if len(keyOrder) == 0 {
			keyOrder = defaultShowKeyOrder
		}
		format := viper.GetString("format")

		// initialize the progress bar, when multiple events are requested
		var bar *pb.ProgressBar
		if len(args) > 1 {
			bar = pb.New(len(args))
			bar.Output = os.Stderr
			bar.Start()
		}

		projectID := viper.GetString("project-id")
		if viper.GetBool("all-projects") {
			projectID = "*"
		}

		getOpts := events.GetOpts{
			ProjectID: projectID,
		}

		var allEvents []events.Event
		for i, id := range args {
			if bar != nil {
				bar.Set(i + 1)
			}
			event, err := events.Get(client, id, getOpts).Extract()
			if err != nil {
				log.Printf("[WARNING] Failed to get %s event: %s", id, err)
				continue
			}
			allEvents = append(allEvents, *event)
		}

		if bar != nil {
			bar.Finish()
		}

		if format == "table" {
			for _, event := range allEvents {
				kv := eventToKV(event)

				// create table
				var buf bytes.Buffer
				table := tablewriter.NewWriter(&buf)
				table.SetColWidth(20)
				table.SetAlignment(3)
				table.SetHeader([]string{"Key", "Value"})

				for _, k := range keyOrder {
					if v, ok := kv[k]; ok {
						table.Append([]string{k, v})
					}
				}

				table.Render()

				fmt.Print(buf.String())
			}
		} else {
			return printEvent(allEvents, format, keyOrder)
		}

		return nil
	},
}

ShowCmd represents the show command

var Version = "dev"

var VersionCmd = &cobra.Command{
	Use:               "version",
	Short:             "Print version information",
	DisableAutoGenTag: true,
	Run: func(cmd *cobra.Command, args []string) {
		fmt.Printf("hermescli %s compiled with %v on %v/%v\n",
			Version, runtime.Version(), runtime.GOOS, runtime.GOARCH)
	},
}

Functions

func Execute

func Execute()

Execute adds all child commands to the root command sets flags appropriately. This is called by main.main(). It only needs to happen once to the rootCmd.

func NewHermesV1Client

func NewHermesV1Client() (*gophercloud.ServiceClient, error)

NewHermesV1Client returns a *ServiceClient for making calls to the OpenStack Lyra v1 API. An error will be returned if authentication or client creation was not possible.