command

Documentation

Index

• Constants
• Variables
• func GetCommandOutput(command string, timeout time.Duration, arg ...string) ([]byte, error)
• func GetConfigPath() (string, error)
• func GetErrorJson(err error) string
• type Command
  • func AddObjToGroupCmd(objectName string, object api.Object, group api.Object) *Command
  • func DeleteCmd(objectName string, object api.Object) *Command
  • func DeleteObjFromGroupCmd(objectName string, object api.Object, group api.Object) *Command
  • func GetCmd(objectName string) *Command
  • func ListCmd(objectName string) *Command
  • func NewCommand(name, usage string, subCommands []*Command) *Command
  • func (c *Command) GetAllSubCommands() []*Command
  • func (c *Command) GetApi(baseUrl, accessToken, appId string, rawOutput bool) *api.Api
  • func (c *Command) GetSubCommand(args []string) *Command
  • func (c *Command) ParseArgs(args []string)
  • func (c *Command) PrintResult(result string, err error)
  • func (c *Command) PrintUsage()
  • func (c *Command) Runnable() bool

Constants

const (
	// Status codes for os.Exit.
	EXIT_SUCCESS              int = 0
	EXIT_SUCCESS_ERROR        int = 1
	EXIT_AUTHENTICATION_ERROR int = 2
	EXIT_FLAG_ERROR           int = 3
)

const (
	DEFAULT_FLAG_VALUE string = `!>dUmmy<!`
)

Variables

var AlertActions = []*Command{
	{
		Name:      "list",
		UsageLine: "alert list [--filter]",
		Long: `
Get all alerts from CoScale Api.

The flags for list alert action are:

Optional:
	--filter
		List actions filtered by unresolved or by unacknowledged.		
`,
		Run: func(cmd *Command, args []string) {
			var filter string
			cmd.Flag.Usage = func() { cmd.PrintUsage() }
			cmd.Flag.StringVar(&filter, "filter", DEFAULT_FLAG_VALUE, "List actions filtered by unresolved or by unacknowledged.")
			cmd.ParseArgs(args)

			switch filter {
			case DEFAULT_FLAG_VALUE:
				cmd.PrintResult(cmd.Capi.GetObjects(alertObjectName))
			case "unresolved":
				cmd.PrintResult(cmd.Capi.GetAlertsBy("selectByResolved"))
			case "unacknowledged":
				cmd.PrintResult(cmd.Capi.GetAlertsBy("selectByAcknowledged"))
			default:
				cmd.PrintUsage()
				os.Exit(EXIT_FLAG_ERROR)
			}
		},
	},
	{
		Name:      "acknowledge",
		UsageLine: "alert acknowledge (--id | --name)",
		Long: `
Acknowledge an alert.

The flags for acknowledge alert action are:
Mandatory:
	--id
		The id of the alert.
	or
	--name
		The name of the alert.
`,
		Run: func(cmd *Command, args []string) {
			var id int64
			cmd.Flag.Usage = func() { cmd.PrintUsage() }
			cmd.Flag.Int64Var(&id, "id", -1, "The id of the alert.")
			cmd.ParseArgs(args)
			var alert = &api.Alert{}
			var err error
			if id == -1 {
				cmd.PrintUsage()
				os.Exit(EXIT_FLAG_ERROR)
			}
			if err = cmd.Capi.GetObjectRef("alert", id, alert); err != nil {
				cmd.PrintResult("", err)
			}
			cmd.PrintResult(cmd.Capi.AlertSolution(alert, "acknowledge"))
		},
	},
	{
		Name:      "resolve",
		UsageLine: "alert resolve (--id | --name)",
		Long: `
Resolve an alert.

The flags for resolve alert action are:
Mandatory:
	--id
		The id of the alert.
	or 
	--name
		The name of the alert.
`,
		Run: func(cmd *Command, args []string) {
			var id int64
			cmd.Flag.Usage = func() { cmd.PrintUsage() }
			cmd.Flag.Int64Var(&id, "id", -1, "The id of the alert.")
			cmd.ParseArgs(args)
			var alert = &api.Alert{}
			var err error
			if id == -1 {
				cmd.PrintUsage()
				os.Exit(EXIT_FLAG_ERROR)
			}
			if err = cmd.Capi.GetObjectRef("alert", id, alert); err != nil {
				cmd.PrintResult("", err)
			}
			cmd.PrintResult(cmd.Capi.AlertSolution(alert, "resolve"))
		},
	},
}

var AlertObject = NewCommand(alertObjectName, "alert <action> [--<field>='<data>']", AlertActions)

var CheckObject = &Command{
	Name:      CheckObjectName,
	UsageLine: `check-config is used to check to api configuration file`,
	Run: func(cmd *Command, args []string) {

		file, err := GetConfigPath()
		if err != nil {
			cmd.PrintResult("", err)
		}

		if _, err := os.Stat(file); err != nil {
			cmd.PrintResult("", err)
		}

		config, err := api.ReadApiConfiguration(file)
		if err != nil {
			cmd.PrintResult("", err)
		}

		api := api.NewApi(config.BaseUrl, config.AccessToken, config.AppId, false)
		err = api.Login()
		if err != nil {
			cmd.PrintResult("", err)
		}
		cmd.PrintResult(`{"msg":"Configuration successfuly checked!"}`, nil)
	},
}

CheckObject is the check-config subcommand and is used to check to api configuration

var CheckObjectName = "check-config"

CheckObjectName is the name of the check-config subcommand

var DataActions = []*Command{
	{
		Name:      "get",
		UsageLine: `data get (--id --subjectIds) [--start --stop --aggregator --aggregateSubjects]`,
		Long: `
Retrieve a batch of data from the datastore.

The flags for get data action are:
Mandatory:
	--id
		Metric id.
	--subjectIds 
		The subject string eg. s1 for server 1, g2 for servergroup 2, a for application.
Optional:		
	--start
		The start timestamp in seconds ago(negative values) or unix timestamp (positive values). [default: 0]
	--stop
		The stop timestamp in seconds ago(negative values) or unix timestamp (positive values). [default: 0]
	--aggregator
		The data aggregator (AVG, MIN, MAX). [default: AVG]
	--aggregateSubjects
		Boolean that indicates if the aggregated value over all subjectIds should be returned. [default: false]
`,
		Run: func(cmd *Command, args []string) {
			var subjectIds, aggregator string
			var aggregateSubjects bool
			var start, stop int
			var id int64
			cmd.Flag.Usage = func() { cmd.PrintUsage() }
			cmd.Flag.Int64Var(&id, "id", -1, "Unique identifier for metric.")
			cmd.Flag.IntVar(&start, "start", 0, "The start timestamp in seconds ago.")
			cmd.Flag.IntVar(&stop, "stop", 0, "The stop timestamp in seconds ago.")
			cmd.Flag.StringVar(&subjectIds, "subjectIds", DEFAULT_FLAG_VALUE, "The subject string")
			cmd.Flag.StringVar(&aggregator, "aggregator", "AVG", "The data aggregator (AVG, MIN, MAX).")
			cmd.Flag.BoolVar(&aggregateSubjects, "aggregateSubjects", false, "Boolean that indicates if the aggregated value over all subjectIds should be returned.")
			cmd.ParseArgs(args)
			if subjectIds == DEFAULT_FLAG_VALUE || id == -1 {
				cmd.PrintUsage()
				os.Exit(EXIT_FLAG_ERROR)
			}
			cmd.PrintResult(cmd.Capi.GetData(start, stop, id, subjectIds, aggregator, aggregateSubjects))
		},
	},
	{
		Name:      "insert",
		UsageLine: `data insert (--datapoint)`,
		Long: `
Create new EventData for a given event.

The flags for data event action are:
Mandatory:
	--datapoint
		Data format is:"M<metric id>:<subject Id>:<seconds ago>:<value/s>" eg:"M1:S100:120:1,2"
`,
		Run: func(cmd *Command, args []string) {
			var datapoint string
			cmd.Flag.Usage = func() { cmd.PrintUsage() }
			cmd.Flag.StringVar(&datapoint, "datapoint", DEFAULT_FLAG_VALUE, "")
			cmd.ParseArgs(args)
			if datapoint == DEFAULT_FLAG_VALUE {
				cmd.PrintUsage()
				os.Exit(EXIT_FLAG_ERROR)
			}
			data, err := api.ParseDataPoint(datapoint)
			if err != nil {
				cmd.PrintUsage()
				os.Exit(EXIT_FLAG_ERROR)
			}
			cmd.PrintResult(cmd.Capi.InsertData(data))
		},
	},
}

var DataObject = NewCommand(dataObjectName, "data <action> [--<field>='<data>']", DataActions)

var EventActions = []*Command{
	ListCmd(eventObjectName),
	GetCmd(eventObjectName),
	DeleteCmd(eventObjectName, &api.Event{}),
	{
		Name:      "new",
		UsageLine: "event new (--name) [--description --attributeDescriptions --source]",
		Long: `
Create new event category.

The flags for new event action are:

Mandatory:
	--name 
		specify name of the event.
Optional:
	--description
		specify the description of the event.
	--attributeDescriptions
		JSON string describing what items the "attribute" of an EventData instance belonging to this Event must have.  [default: "[]"]
	--source
		Describes who added the event. Can be chosen by the user. [default: "cli"]
`,
		Run: func(cmd *Command, args []string) {
			var name, description, attributeDescriptions, source string
			cmd.Flag.Usage = func() { cmd.PrintUsage() }
			cmd.Flag.StringVar(&name, "name", DEFAULT_FLAG_VALUE, "specify the event name of the event")
			cmd.Flag.StringVar(&description, "description", "", "specify the description of the event")
			cmd.Flag.StringVar(&attributeDescriptions, "attributeDescriptions", "[]", "")
			cmd.Flag.StringVar(&source, "source", "cli", "Describes who added the event")
			cmd.ParseArgs(args)

			if name == DEFAULT_FLAG_VALUE {
				cmd.PrintUsage()
				os.Exit(EXIT_FLAG_ERROR)
			}
			cmd.PrintResult(cmd.Capi.CreateEvent(name, description, attributeDescriptions, source, ""))
		},
	},
	{
		Name:      "update",
		UsageLine: "event update (--name | --id) [--description --attributeDescriptions --source]",
		Long: `
Update a CoScale event object.

The flags for update event action are:
The name or id should be specified
	--id
		Unique identifier, if we want to update the name of the event, this become mandatory
	--name 
		specify the event name of the event.
	--description
		specify the description of the event.
	--attributeDescriptions
		JSON string describing what items the "attribute" of an EventData instance belonging to this Event must have.
	--source
		Describes who added the event. Can be chosen by the user. [default: "cli"]
`,
		Run: func(cmd *Command, args []string) {
			var name, description, attributeDescriptions, source string
			var id int64
			cmd.Flag.Usage = func() { cmd.PrintUsage() }
			cmd.Flag.StringVar(&name, "name", DEFAULT_FLAG_VALUE, "specify the event name of the event")
			cmd.Flag.StringVar(&description, "description", DEFAULT_FLAG_VALUE, "specify the description of the event")
			cmd.Flag.StringVar(&attributeDescriptions, "attributeDescriptions", DEFAULT_FLAG_VALUE, "")
			cmd.Flag.StringVar(&source, "source", DEFAULT_FLAG_VALUE, "Describes who added the event")
			cmd.Flag.Int64Var(&id, "id", -1, "Unique identifier")
			cmd.ParseArgs(args)

			var eventObj = &api.Event{}
			var err error
			if id != -1 {
				err = cmd.Capi.GetObjectRef("event", id, eventObj)
			} else if name != DEFAULT_FLAG_VALUE {
				err = cmd.Capi.GetObejctRefByName("event", name, eventObj)
			} else {
				cmd.PrintUsage()
				os.Exit(EXIT_FLAG_ERROR)
			}
			if err != nil {
				cmd.PrintResult("", err)
			}

			if name != DEFAULT_FLAG_VALUE {
				eventObj.Name = name
			}
			if description != DEFAULT_FLAG_VALUE {
				eventObj.Description = description
			}
			if attributeDescriptions != DEFAULT_FLAG_VALUE {
				eventObj.AttributeDescriptions = attributeDescriptions
			}
			if source != DEFAULT_FLAG_VALUE {
				eventObj.Source = source
			}

			cmd.PrintResult(cmd.Capi.UpdateEvent(eventObj))
		},
	},
	{
		Name:      "data",
		UsageLine: "event data (--name --id --message --subject) [--attribute --timestamp --stopTime]",
		Long: `
Insert event data.

The flags for data event action are:
Mandatory:
	--name 
		specify the event name.
	--id
		specify the event id.
	Only one from id/name is neccessary.
		
	--message
		The message for the event data.	
	--subject
		The subject for the event data. The subject is structured as follows:
		s<serverId> for a server, g<servergroupId> for a server group, a for the application.
Optional:	
	--attribute
		JSON String detailing the progress of the event.
	--timestamp
		Timestamp in seconds ago(negative values) or unix timestamp(positive values). [default: 0]
	--stopTime
		The time at which the EventData stopped in seconds ago(negative values) or unix timestamp(positive values). [default: 0]
		`,
		Run: func(cmd *Command, args []string) {
			var id, timestamp, stopTime int64
			var name, message, subject, attribute string
			cmd.Flag.Usage = func() { cmd.PrintUsage() }
			cmd.Flag.StringVar(&name, "name", DEFAULT_FLAG_VALUE, "event name")
			cmd.Flag.StringVar(&message, "message", DEFAULT_FLAG_VALUE, "message for the event data")
			cmd.Flag.StringVar(&subject, "subject", DEFAULT_FLAG_VALUE, "subject for the event data")
			cmd.Flag.StringVar(&attribute, "attribute", "{}", "JSON String detailing the progress of the event")
			cmd.Flag.Int64Var(&id, "id", -1, "Unique identifier")
			cmd.Flag.Int64Var(&timestamp, "timestamp", 0, "Timestamp in seconds ago")
			cmd.Flag.Int64Var(&stopTime, "stopTime", 0, "The time at which the EventData stopped in seconds ago")
			cmd.ParseArgs(args)

			var eventObj = &api.Event{}
			var err error

			flagErr := message == DEFAULT_FLAG_VALUE || subject == DEFAULT_FLAG_VALUE
			if !flagErr {
				if id != -1 {
					err = cmd.Capi.GetObjectRef("event", id, eventObj)
				} else if name != DEFAULT_FLAG_VALUE {
					err = cmd.Capi.GetObejctRefByName("event", name, eventObj)
				} else {
					flagErr = true
				}
			}
			if flagErr {
				cmd.PrintUsage()
				os.Exit(EXIT_FLAG_ERROR)
			}
			if err != nil {
				cmd.PrintResult("", err)
			}
			cmd.PrintResult(cmd.Capi.InsertEventData(eventObj.ID, message, subject, attribute, timestamp, stopTime))
		},
	},
}

var EventObject = NewCommand(eventObjectName, "event <action> [--<field>='<data>']", EventActions)

var MetricActions = []*Command{
	ListCmd("metric"),
	{
		Name:      "listbygroup",
		UsageLine: `metric listbygroup (--id | --name)`,
		Long: `
Get all metrics from a metric group

The flags for listbygroup metric action are:

Mandatory:
	--id
		Unique identifier for a metricgroup
	or 
	--name 
		specify the name of the metrigroup.
`,
		Run: func(cmd *Command, args []string) {
			var id int64
			var name string
			cmd.Flag.Usage = func() { cmd.PrintUsage() }
			cmd.Flag.Int64Var(&id, "id", -1, "Unique identifier")
			cmd.Flag.StringVar(&name, "name", DEFAULT_FLAG_VALUE, "Name for the metric group.")

			cmd.ParseArgs(args)

			var metricGroupObj = &api.MetricGroup{}
			var err error
			if id != -1 {
				err = cmd.Capi.GetObjectRef("metricgroup", id, metricGroupObj)
			} else if name != DEFAULT_FLAG_VALUE {
				err = cmd.Capi.GetObejctRefByName("metricgroup", name, metricGroupObj)
			} else {
				cmd.PrintUsage()
				os.Exit(EXIT_FLAG_ERROR)
			}
			if err != nil {
				cmd.PrintResult("", err)
			}

			cmd.PrintResult(cmd.Capi.GetMetricsByGroup(metricGroupObj))
		},
	},
	{
		Name:      "new",
		UsageLine: `metric new (--name --dataType --subject) [--period --description --unit --attachTo --source]`,
		Long: `
Create a new CoScale metric object.

The flags for new metric action are:

Mandatory:
	--name 
		specify the name of the metric.
	--dataType
		The following data types are defined: "LONG", "DOUBLE", "HISTOGRAM".
	--subject
		A metric is defined on either a "SERVER", "GROUP" or "APPLICATION". This allows for metric per server, per server group or on the whole application.
Optional:
	--period
		The amount of time (in seconds) between 2 data points. [default: 60]
	--description
		Description for the metric. [default: ""]
	--unit
		The unit for the metric. This is shown on the axis in the widgets. [default: ""]
	--attachTo
		Describes what the relation of this Metric is. Options are SERVER, SERVERGROUP, APPLICATION, REQUEST, DATABASE, QUERY and ANALYSIS.
	--source
		Describes who added the metric. Can be chosen by the user. [default: "cli"]
`,
		Run: func(cmd *Command, args []string) {
			var name, description, dataType, subject, unit, attachTo, source string
			var period int
			cmd.Flag.Usage = func() { cmd.PrintUsage() }
			cmd.Flag.StringVar(&name, "name", DEFAULT_FLAG_VALUE, "Name for the metric.")
			cmd.Flag.StringVar(&description, "description", "", "Description for the metric.")
			cmd.Flag.StringVar(&dataType, "dataType", DEFAULT_FLAG_VALUE, `The following data types are defined: "LONG", "DOUBLE", "HISTOGRAM".`)
			cmd.Flag.StringVar(&subject, "subject", DEFAULT_FLAG_VALUE, `A metric is defined on either a "SERVER", "GROUP" or "APPLICATION".`)
			cmd.Flag.StringVar(&unit, "unit", "", "The unit for the metric.")
			cmd.Flag.StringVar(&attachTo, "attachTo", "", "Describes what the relation of this Metric is.")
			cmd.Flag.StringVar(&source, "source", "cli", "Describes who added the metric.")
			cmd.Flag.IntVar(&period, "period", 60, "The amount of time (in seconds) between 2 data points.")
			cmd.ParseArgs(args)

			if name == DEFAULT_FLAG_VALUE || dataType == DEFAULT_FLAG_VALUE || subject == DEFAULT_FLAG_VALUE {
				cmd.PrintUsage()
				os.Exit(EXIT_FLAG_ERROR)
			}
			cmd.PrintResult(cmd.Capi.CreateMetric(name, description, dataType, unit, subject, source, period))
		},
	},
	{
		Name:      "update",
		UsageLine: `metric update (--name | --id) [--description --dataType --subject --unit --period --attachTo --source]`,
		Long: `
Update a CoScale metric object.

The flags for new event action are:

Mandatory:
	--name 
		specify the event name of the event.
Optional:
	--id
		Unique identifier, if we want to update the name of a event, this become mandatory
	--description
			Description for the metric.
	--dataType
			The following data types are defined: "LONG", "DOUBLE", "HISTOGRAM".
	--subject
			A metric is defined on either a "SERVER", "GROUP" or "APPLICATION". This allows for metric per server, per server group or on the whole application.
	--unit
			The unit for the metric. This is shown on the axis in the widgets. [default: ""]
	--attachTo
			Describes what the relation of this Metric is. Options are SERVER, SERVERGROUP, APPLICATION, REQUEST, DATABASE, QUERY and ANALYSIS.
	--source
			Describes who added the event. Can be chosen by the user. [default: "cli"]
	--period
			The amount of time (in seconds) between 2 data points. [default: 60]
`,
		Run: func(cmd *Command, args []string) {
			var name, description, dataType, subject, unit, attachTo, source string
			var period int
			var id int64
			cmd.Flag.Usage = func() { cmd.PrintUsage() }
			cmd.Flag.Int64Var(&id, "id", -1, "Unique identifier")
			cmd.Flag.StringVar(&name, "name", DEFAULT_FLAG_VALUE, "Name for the metric.")
			cmd.Flag.StringVar(&description, "description", DEFAULT_FLAG_VALUE, "Description for the metric.")
			cmd.Flag.StringVar(&dataType, "dataType", DEFAULT_FLAG_VALUE, `The following data types are defined: "LONG", "DOUBLE", "HISTOGRAM".`)
			cmd.Flag.StringVar(&subject, "subject", "", `A metric is defined on either a "SERVER", "GROUP" or "APPLICATION".`)
			cmd.Flag.StringVar(&unit, "unit", DEFAULT_FLAG_VALUE, "The unit for the metric.")
			cmd.Flag.StringVar(&attachTo, "attachTo", "", "Describes what the relation of this Metric is.")
			cmd.Flag.StringVar(&source, "source", DEFAULT_FLAG_VALUE, "Describes who added the metric.")
			cmd.Flag.IntVar(&period, "period", -1, "The amount of time (in seconds) between 2 data points.")
			cmd.ParseArgs(args)

			var metricObj = &api.Metric{}
			var err error
			if name == DEFAULT_FLAG_VALUE {
				cmd.PrintUsage()
				os.Exit(EXIT_FLAG_ERROR)
			}
			if id != -1 {
				err = cmd.Capi.GetObjectRef("metric", id, metricObj)
			} else {
				err = cmd.Capi.GetObejctRefByName("metric", name, metricObj)
			}
			if err != nil {
				cmd.PrintResult("", err)
			}

			if name != DEFAULT_FLAG_VALUE {
				metricObj.Name = name
			}
			if dataType != DEFAULT_FLAG_VALUE {
				metricObj.DataType = dataType
			}
			if description != DEFAULT_FLAG_VALUE {
				metricObj.Description = description
			}
			if period != -1 {
				metricObj.Period = period
			}
			if source != DEFAULT_FLAG_VALUE {
				metricObj.Source = source
			}
			if unit != DEFAULT_FLAG_VALUE {
				metricObj.Unit = unit
			}

			cmd.PrintResult(cmd.Capi.UpdateMetric(metricObj))
		},
	},
}

var MetricGroupActions = []*Command{
	ListCmd("metricgroup"),
	GetCmd("metricgroup"),
	AddObjToGroupCmd("metric", &api.Metric{}, &api.MetricGroup{}),
	DeleteObjFromGroupCmd("metric", &api.Metric{}, &api.MetricGroup{}),
	{
		Name:      "new",
		UsageLine: `servergroup new (--name --subject) [--description --state --source]`,
		Long: `
Create a new CoScale metricgroup object.

The flags for new metricgroup action are:

Mandatory:
	--name 
		Name for the metric group.
	--subject
		The subject type of the metric group. "APPLICATION", "SERVERGROUP" or "SERVER".
Optional:
	--description
		Description for the metric group.
	--type
		Describes the type of metric group.
	--state
		"ENABLED": capturing data, "INACTIVE": not capturing data, "DISABLED": not capturing data and not shown on the dashboard.
	--source
		Describes who added the metric group. Can be chosen by the user. [default: "cli"]
`,
		Run: func(cmd *Command, args []string) {
			var name, description, Type, state, source, subject string
			cmd.Flag.Usage = func() { cmd.PrintUsage() }
			cmd.Flag.StringVar(&name, "name", DEFAULT_FLAG_VALUE, "Name for the metric group.")
			cmd.Flag.StringVar(&description, "description", "", "Description for the metric group.")
			cmd.Flag.StringVar(&Type, "type", "", "Describes the type of metric group.")
			cmd.Flag.StringVar(&subject, "subject", DEFAULT_FLAG_VALUE, `The subject type of the metric group. "APPLICATION", "SERVERGROUP" or "SERVER".`)
			cmd.Flag.StringVar(&state, "state", "ENABLED", `"ENABLED": capturing data, "INACTIVE": not capturing data, "DISABLED": not capturing data and not shown on the dashboard.`)
			cmd.Flag.StringVar(&source, "source", "cli", "Describes who added the metric group.")
			cmd.ParseArgs(args)

			if name == DEFAULT_FLAG_VALUE || subject == DEFAULT_FLAG_VALUE {
				cmd.PrintUsage()
				os.Exit(EXIT_FLAG_ERROR)
			}
			cmd.PrintResult(cmd.Capi.CreateMetricGroup(name, description, Type, state, subject, source))
		},
	},
	{
		Name:      "update",
		UsageLine: `metricgroup update (--name | --id) [--description --type --state --source]`,
		Long: `
Update a CoScale metricgroup object.

The flags for update metricgroup action are:

Mandatory:
	--name 
		Specify the name of the metricgroup.
Optional:
	--id
		Unique identifier, if we want to update the name of the metricgroup, this become mandatory.
	--description
		Description for the metric group.
	--type
		Describes the type of metric group.
	--state
		"ENABLED": capturing data, "INACTIVE": not capturing data, "DISABLED": not capturing data and not shown on the dashboard.
	--source
		Describes who added the metric group. Can be chosen by the user. [default: "cli"]
`,
		Run: func(cmd *Command, args []string) {
			var id int64
			var name, description, Type, state, source string
			cmd.Flag.Usage = func() { cmd.PrintUsage() }
			cmd.Flag.Int64Var(&id, "id", -1, "Unique identifier")
			cmd.Flag.StringVar(&name, "name", DEFAULT_FLAG_VALUE, "Name for the metric group.")
			cmd.Flag.StringVar(&description, "description", DEFAULT_FLAG_VALUE, "Description for the metric group.")
			cmd.Flag.StringVar(&Type, "type", DEFAULT_FLAG_VALUE, "Describes the type of metric group.")
			cmd.Flag.StringVar(&state, "state", DEFAULT_FLAG_VALUE, `"ENABLED": capturing data, "INACTIVE": not capturing data, "DISABLED": not capturing data and not shown on the dashboard.`)
			cmd.Flag.StringVar(&source, "source", DEFAULT_FLAG_VALUE, "Describes who added the metric group.")
			cmd.ParseArgs(args)

			if name == DEFAULT_FLAG_VALUE {
				cmd.PrintUsage()
				os.Exit(EXIT_FLAG_ERROR)
			}

			var metricGroupObj = &api.MetricGroup{}
			var err error
			if name == "" {
				cmd.PrintUsage()
				os.Exit(EXIT_FLAG_ERROR)
			}
			if id != -1 {
				err = cmd.Capi.GetObjectRef("metricgroup", id, metricGroupObj)
			} else {
				err = cmd.Capi.GetObejctRefByName("metricgroup", name, metricGroupObj)
			}
			if err != nil {
				cmd.PrintResult("", err)
			}

			if name != DEFAULT_FLAG_VALUE {
				metricGroupObj.Name = name
			}
			if description != DEFAULT_FLAG_VALUE {
				metricGroupObj.Description = description
			}
			if Type != DEFAULT_FLAG_VALUE {
				metricGroupObj.Type = Type
			}
			if source != DEFAULT_FLAG_VALUE {
				metricGroupObj.Source = source
			}
			if state != DEFAULT_FLAG_VALUE {
				metricGroupObj.State = state
			}
			cmd.PrintResult(cmd.Capi.UpdateMetricGroup(metricGroupObj))
		},
	},
}

var MetricGroupObject = NewCommand("metricgroup", "metricgroup <action> [--<field>='<data>']", MetricGroupActions)

var MetricObject = NewCommand("metric", "metric <action> [--<field>='<data>']", MetricActions)

var ServerActions = []*Command{
	ListCmd("server"),
	GetCmd("server"),
	DeleteCmd("server", &api.Server{}),
	{
		Name:      "new",
		UsageLine: "server new (--name) [--description --serverType --source]",
		Long: `
Create a new CoScale server object.

The flags for new server action are:

Mandatory:
	--name 
		Name for the server.
Optional:
	--description
		Description for the server.
	--serverType
		Describes the type of server.
	--source
		Describes who added the server. Can be chosen by the user. [default: "cli"]
`,
		Run: func(cmd *Command, args []string) {
			var name, description, serverType, source string
			cmd.Flag.Usage = func() { cmd.PrintUsage() }
			cmd.Flag.StringVar(&name, "name", DEFAULT_FLAG_VALUE, "Name for the server.")
			cmd.Flag.StringVar(&description, "description", "", "Description for the server.")
			cmd.Flag.StringVar(&serverType, "serverType", "", "Describes the type of server.")
			cmd.Flag.StringVar(&source, "source", "cli", "Describes who added the server.")
			cmd.ParseArgs(args)

			if name == DEFAULT_FLAG_VALUE {
				cmd.PrintUsage()
				os.Exit(EXIT_FLAG_ERROR)
			}
			cmd.PrintResult(cmd.Capi.CreateServer(name, description, serverType, source))
		},
	},
	{
		Name:      "update",
		UsageLine: "server update (--name | --id) [--description --serverType --state --source]",
		Long: `
Update a CoScale server object.

The flags for update server action are:
The name or id should be specified
	--id
		Unique identifier, if we want to update the name of the server, this become mandatory
	--name 
		specify the name of the server.
	--description
		Description for the server.
	--serverType
		Describes the type of server.
	--source
		Describes who added the server. Can be chosen by the user. [default: "cli"]
	--state
	 	"ENABLED": capturing data, "INACTIVE": not capturing data, "DISABLED": not capturing data and not shown on the dashboard.
`,
		Run: func(cmd *Command, args []string) {
			var name, description, Type, source, state string
			var id int64
			cmd.Flag.Usage = func() { cmd.PrintUsage() }
			cmd.Flag.StringVar(&name, "name", DEFAULT_FLAG_VALUE, "Name for the server.")
			cmd.Flag.StringVar(&description, "description", DEFAULT_FLAG_VALUE, "Description for the server.")
			cmd.Flag.StringVar(&Type, "type", DEFAULT_FLAG_VALUE, "Describes the type of server.")
			cmd.Flag.StringVar(&source, "source", DEFAULT_FLAG_VALUE, "Describes who added the server.")
			cmd.Flag.StringVar(&state, "state", DEFAULT_FLAG_VALUE, `"ENABLED": capturing data, "INACTIVE": not capturing data, "DISABLED": not capturing data and not shown on the dashboard.`)
			cmd.Flag.Int64Var(&id, "id", -1, "Unique identifier")
			cmd.ParseArgs(args)

			var serverObj = &api.Server{}
			var err error
			if id != -1 {
				err = cmd.Capi.GetObjectRef("server", id, serverObj)
			} else if name != DEFAULT_FLAG_VALUE {
				err = cmd.Capi.GetObejctRefByName("server", name, serverObj)
			} else {
				cmd.PrintUsage()
				os.Exit(EXIT_FLAG_ERROR)
			}
			if err != nil {
				cmd.PrintResult("", err)
			}

			if name != DEFAULT_FLAG_VALUE {
				serverObj.Name = name
			}
			if description != DEFAULT_FLAG_VALUE {
				serverObj.Description = description
			}
			if Type != DEFAULT_FLAG_VALUE {
				serverObj.Type = Type
			}
			if source != DEFAULT_FLAG_VALUE {
				serverObj.Source = source
			}
			if state != DEFAULT_FLAG_VALUE {
				serverObj.State = state
			}

			cmd.PrintResult(cmd.Capi.UpdateServer(serverObj))
		},
	},
}

var ServerGroupActions = []*Command{
	ListCmd("servergroup"),
	GetCmd("servergroup"),
	DeleteCmd("servergroup", &api.ServerGroup{}),
	{
		Name:      "new",
		UsageLine: `servergroup new (--name) [--description --type --state --source]`,
		Long: `
Create a new CoScale servergroup object.

The flags for new servergroup action are:

Mandatory:
	--name 
		Name for the server group.
Optional:
	--description
		Description for the server group.
	--type
		Describes the type of server group.
	--state
		"ENABLED": capturing data, "INACTIVE": not capturing data, "DISABLED": not capturing data and not shown on the dashboard.	
	--source
		Describes who added the server group. Can be chosen by the user. [default: "cli"]
`,
		Run: func(cmd *Command, args []string) {
			var name, description, Type, state, source string
			cmd.Flag.Usage = func() { cmd.PrintUsage() }
			cmd.Flag.StringVar(&name, "name", DEFAULT_FLAG_VALUE, "Name for the server group.")
			cmd.Flag.StringVar(&description, "description", "", "Description for the server group.")
			cmd.Flag.StringVar(&Type, "type", "", "Describes the type of server group.")
			cmd.Flag.StringVar(&state, "state", "", `"ENABLED": capturing data, "INACTIVE": not capturing data, "DISABLED": not capturing data and not shown on the dashboard.`)
			cmd.Flag.StringVar(&source, "source", "cli", "Describes who added the server group.")
			cmd.ParseArgs(args)

			if name == DEFAULT_FLAG_VALUE {
				cmd.PrintUsage()
				os.Exit(EXIT_FLAG_ERROR)
			}
			cmd.PrintResult(cmd.Capi.CreateServerGroup(name, description, Type, state, source))
		},
	},
	{
		Name:      "update",
		UsageLine: `servergroup update (--name | --id) [--description --type --state --source]`,
		Long: `
Update a CoScale servergroup object.

The flags for update servergroup action are:
The name or id should be specified
	--id
		Unique identifier, if we want to update the name of the servergroup, this become mandatory
	--name 
		Name for the server group.
	--description
		Description for the server group.
	--type
		Describes the type of server group.
	--state
		"ENABLED": capturing data, "INACTIVE": not capturing data, "DISABLED": not capturing data and not shown on the dashboard.	
	--source
		Describes who added the server group. Can be chosen by the user. [default: "cli"]
`,
		Run: func(cmd *Command, args []string) {
			var name, description, Type, source, state string
			var id int64
			cmd.Flag.Usage = func() { cmd.PrintUsage() }
			cmd.Flag.Int64Var(&id, "id", -1, "Unique identifier.")
			cmd.Flag.StringVar(&name, "name", DEFAULT_FLAG_VALUE, "Name for the server group.")
			cmd.Flag.StringVar(&description, "description", DEFAULT_FLAG_VALUE, "Description for the server group.")
			cmd.Flag.StringVar(&Type, "type", DEFAULT_FLAG_VALUE, "Describes the type of server group.")
			cmd.Flag.StringVar(&state, "state", DEFAULT_FLAG_VALUE, `"ENABLED": capturing data, "INACTIVE": not capturing data, "DISABLED": not capturing data and not shown on the dashboard.`)
			cmd.Flag.StringVar(&source, "source", DEFAULT_FLAG_VALUE, "Describes who added the server. Can be chosen by the user.")
			cmd.ParseArgs(args)

			var serverGroupObj = &api.ServerGroup{}
			var err error
			if id != -1 {
				err = cmd.Capi.GetObjectRef("servergroup", id, serverGroupObj)
			} else if name != DEFAULT_FLAG_VALUE {
				err = cmd.Capi.GetObejctRefByName("servergroup", name, serverGroupObj)
			} else {
				cmd.PrintUsage()
				os.Exit(EXIT_FLAG_ERROR)
			}
			if err != nil {
				cmd.PrintResult("", err)
			}

			if name != DEFAULT_FLAG_VALUE {
				serverGroupObj.Name = name
			}
			if description != DEFAULT_FLAG_VALUE {
				serverGroupObj.Description = description
			}
			if Type != DEFAULT_FLAG_VALUE {
				serverGroupObj.Type = Type
			}
			if source != DEFAULT_FLAG_VALUE {
				serverGroupObj.Source = source
			}
			if state != DEFAULT_FLAG_VALUE {
				serverGroupObj.State = state
			}

			cmd.PrintResult(cmd.Capi.UpdateServerGroup(serverGroupObj))
		},
	},
	AddObjToGroupCmd("server", &api.Server{}, &api.ServerGroup{}),
	DeleteObjFromGroupCmd("server", &api.Server{}, &api.ServerGroup{}),
}

var ServerGroupObject = NewCommand("servergroup", "servergroup <action> [--<field>='<data>']", ServerGroupActions)

var ServerObject = NewCommand("server", "server <action> [--<field>='<data>']", ServerActions)

Functions

func GetCommandOutput

func GetCommandOutput(command string, timeout time.Duration, arg ...string) ([]byte, error)

GetCommandOutput returns stdout of command as a string

func GetConfigPath

func GetConfigPath() (string, error)

GetConfigPath is used to return the absolut path of the api configuration file

func GetErrorJson

func GetErrorJson(err error) string

GetErrorJson return only the json string from a error message from api

Types

type Command

type Command struct {
	Name        string
	UsageLine   string
	Long        string
	SubCommands []*Command
	Capi        *api.Api //api connector
	Flag        flag.FlagSet
	Run         func(cmd *Command, args []string)
}

func AddObjToGroupCmd

func AddObjToGroupCmd(objectName string, object api.Object, group api.Object) *Command

func DeleteCmd

func DeleteCmd(objectName string, object api.Object) *Command

func DeleteObjFromGroupCmd

func DeleteObjFromGroupCmd(objectName string, object api.Object, group api.Object) *Command

func GetCmd

func GetCmd(objectName string) *Command

func ListCmd

func ListCmd(objectName string) *Command

func NewCommand

func NewCommand(name, usage string, subCommands []*Command) *Command

func (*Command) GetAllSubCommands

func (c *Command) GetAllSubCommands() []*Command

func (*Command) GetApi

func (c *Command) GetApi(baseUrl, accessToken, appId string, rawOutput bool) *api.Api

GetApi returns a Api object

func (*Command) GetSubCommand

func (c *Command) GetSubCommand(args []string) *Command

func (*Command) ParseArgs

func (c *Command) ParseArgs(args []string)

func (*Command) PrintResult

func (c *Command) PrintResult(result string, err error)

func (*Command) PrintUsage

func (c *Command) PrintUsage()

func (*Command) Runnable

func (c *Command) Runnable() bool