+ Upgrade to latest version

Author: Samuel Vandamme

src/coscale/api/api.go

@@ -198,7 +198,7 @@ type LoginData struct {
 }
 
 // Login to the Api, returns the token and an error.
-func (api *Api) login() error {
+func (api *Api) Login() error {
 
 	data := map[string][]string{
 		"accessToken": {api.accessToken},
@@ -222,7 +222,7 @@ func (api *Api) login() error {
 func (api *Api) makeRawCall(method string, uri string, data map[string][]string, timeout time.Duration) ([]byte, error) {
 	// Not authenticated yet, try login.
 	if api.token == "" {
-		if err := api.login(); err != nil {
+		if err := api.Login(); err != nil {
 			return nil, err
 		}
 	}
@@ -233,7 +233,7 @@ func (api *Api) makeRawCall(method string, uri string, data map[string][]string,
 		if _, ok := err.(UnauthorizedError); ok {
 			// unauthorizedError: the token might have experied. Performing login again
 			// and retrying the request.
-			if err := api.login(); err != nil {
+			if err := api.Login(); err != nil {
 				api.token = ""
 				return nil, err
 			}

src/coscale/api/event.go

@@ -1,9 +1,6 @@
 package api
 
-import (
-	"fmt"
-	"time"
-)
+import "fmt"
 
 type Event struct {
 	ID                    int64
@@ -62,11 +59,10 @@ func (api *Api) DeleteEvent(event *Event) error {
 }
 
 func (api *Api) InsertEventData(id int64, message, subject, attribute string, timestamp, stopTime int64) (string, error) {
-	now := int64(time.Now().Unix())
 	data := map[string][]string{
 		"message":   {message},
-		"timestamp": {fmt.Sprintf("%d", timestamp - now)},
-		"stopTime":  {fmt.Sprintf("%d", stopTime - now)},
+		"timestamp": {fmt.Sprintf("%d", timestamp)},
+		"stopTime":  {fmt.Sprintf("%d", stopTime)},
 		"subject":   {subject},
 		"attribute": {attribute},
 	}

src/coscale/cli.go

@@ -6,7 +6,7 @@ import (
 	"os"
 )
 
-//main command of Coscale cli-cmd
+//main command of Coscale coscale-cli
 func main() {
 
 	var subCommands = []*command.Command{
@@ -17,6 +17,7 @@ func main() {
 		command.MetricGroupObject,
 		command.DataObject,
 		command.AlertObject,
+		command.CheckObject,
 	}
 	var usage = os.Args[0] + ` <object> <action> [--<field>='<data>']`
 	var app = command.NewCommand(os.Args[0], usage, subCommands)

src/coscale/command/check.go

@@ -0,0 +1,38 @@
+package command
+
+import (
+	"coscale/api"
+	"os"
+)
+
+// CheckObjectName is the name of the check-config subcommand
+var CheckObjectName = "check-config"
+
+// CheckObject is the check-config subcommand and is used to check to api configuration
+var CheckObject = &Command{
+	Name:      CheckObjectName,
+	UsageLine: `check-config is used to check to api configuration file`,
+	Run: func(cmd *Command, args []string) {
+		// check for getting the config file path
+		file, err := GetConfigPath()
+		if err != nil {
+			cmd.PrintResult("", err)
+		}
+		// check if the file actually exists
+		if _, err := os.Stat(file); err != nil {
+			cmd.PrintResult("", err)
+		}
+		// check if the configuration file can be parsed
+		config, err := api.ReadApiConfiguration(file)
+		if err != nil {
+			cmd.PrintResult("", err)
+		}
+		// check if we can loggin with this configuration
+		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)
+	},
+}

src/coscale/command/command.go

@@ -1,14 +1,19 @@
 package command
 
 import (
+	"bytes"
 	"coscale/api"
+	"errors"
 	"flag"
 	"fmt"
 	"io"
 	"os"
+	"os/exec"
 	"path/filepath"
+	"runtime"
 	"strings"
 	"text/template"
+	"time"
 	"unicode"
 	"unicode/utf8"
 )
@@ -102,14 +107,14 @@ func (c *Command) PrintUsage() {
 	os.Exit(2)
 }
 
-//return a Api object
+// GetApi returns a Api object
 func (c *Command) GetApi(baseUrl, accessToken, appId string, rawOutput bool) *api.Api {
 	if accessToken == "" || appId == "" {
-		dir, err := filepath.Abs(filepath.Dir(os.Args[0]))
+		configPath, err := GetConfigPath()
 		if err != nil {
 			os.Exit(EXIT_FLAG_ERROR)
 		}
-		config, err := api.ReadApiConfiguration(dir + "/api.conf")
+		config, err := api.ReadApiConfiguration(configPath)
 		if err != nil {
 			c.PrintUsage()
 		}
@@ -142,26 +147,27 @@ func (c *Command) ParseArgs(args []string) {
 
 func (c *Command) PrintResult(result string, err error) {
 	if err == nil {
-		fmt.Fprint(os.Stdout, result)
+		fmt.Fprintln(os.Stdout, result)
 		os.Exit(EXIT_SUCCESS)
 	} else if api.IsAuthenticationError(err) {
-		fmt.Fprint(os.Stderr, `{"msg":"Authentication failed!"}`)
+		fmt.Fprintln(os.Stderr, `{"msg":"Authentication failed!"}`)
 		os.Exit(EXIT_AUTHENTICATION_ERROR)
 	} else {
-		fmt.Fprintf(os.Stderr, GetErrorJson(err))
+		fmt.Fprintln(os.Stderr, GetErrorJson(err))
 		os.Exit(EXIT_SUCCESS_ERROR)
 	}
 }
 
 // GetErrorJson return only the json string from a error message from api
 func GetErrorJson(err error) string {
-	if strings.Index(err.Error(), `{`) > -1 {
+	index := strings.Index(err.Error(), `{`)
+	if index > -1 {
 		return err.Error()[strings.Index(err.Error(), `{`):]
 	}
-	return err.Error()
+	return fmt.Sprintf(`{"msg":"%s"}`, err.Error())
 }
 
-var usageTemplate = `cli-cmd a tool for CoScale Api.
+var usageTemplate = `coscale-cli a tool for CoScale Api.
 
 Usage:
 	{{.UsageLine}}
@@ -178,16 +184,68 @@ Usage:
 The json objects are returned formatted by default, but can be returned on 1 line by using:
 	--rawOutput
 	
-The CoScale api configuration (authentication) by default will be taken from api.conf file,
-placed in the same folder with the cli-cmd. api.conf file it is the same configuration file
-used by the CoScale agent. If the api.conf file doesn't exists, the informations also can be
-provided on the command line using:
+By default the CoScale api credentials (authentication) will be taken from api.conf
+located in the same directory as the coscale-cli binary. If the file does not exist,
+the credentials can also be provided on the command line using:
 	--api-url
 		Base url for the api (optional, default = "https://api.coscale.com/").
 	--app-id
 		The application id.
 	--access-token
 		A valid access token for the given application.
 
-Use "cli-cmd [object] <help>" for more information about a command.
+Use "coscale-cli [object] <help>" for more information about a command.
 `
+
+// GetConfigPath is used to return the absolut path of the api configuration file
+func GetConfigPath() (string, error) {
+	configFile := "/api.conf"
+	dir, err := filepath.Abs(filepath.Dir(os.Args[0]))
+	if err != nil {
+		os.Exit(EXIT_FLAG_ERROR)
+	}
+	configPath := dir + configFile
+	if _, err := os.Stat(configPath); err == nil {
+		return configPath, nil
+	}
+	var cmdName string
+	if runtime.GOOS == "windows" {
+		cmdName = "where"
+	} else {
+		cmdName = "which"
+	}
+	response, err := GetCommandOutput(cmdName, 2*time.Second, os.Args[0])
+	path := bytes.Split(response, []byte("\n"))[0]
+	if err != nil {
+		return "", err
+	}
+	return filepath.Dir(string(path)) + configFile, nil
+}
+
+// GetCommandOutput returns stdout of command as a string
+func GetCommandOutput(command string, timeout time.Duration, arg ...string) ([]byte, error) {
+	var err error
+	var stdOut bytes.Buffer
+	var stdErr bytes.Buffer
+	var c = make(chan []byte)
+	cmd := exec.Command(command, arg...)
+	cmd.Stdout = &stdOut
+	cmd.Stderr = &stdErr
+	if err = cmd.Start(); err != nil {
+		return nil, fmt.Errorf("%s %s", err.Error(), stdErr.String())
+	}
+	go func() {
+		err = cmd.Wait()
+		c <- stdOut.Bytes()
+	}()
+	time.AfterFunc(timeout, func() {
+		cmd.Process.Kill()
+		err = errors.New("Maxruntime exceeded")
+		c <- nil
+	})
+	response := <-c
+	if err != nil {
+		fmt.Errorf("%s %s", err.Error(), stdErr.String())
+	}
+	return response, nil
+}

src/coscale/command/event.go

@@ -167,6 +167,13 @@ Optional:
 			if err != nil {
 				cmd.PrintResult("", err)
 			}
+			// be sure that the time values are negative
+			if timestamp > 0 {
+				timestamp = -timestamp
+			}
+			if stopTime > 0 {
+				stopTime = -stopTime
+			}
 			cmd.PrintResult(cmd.Capi.InsertEventData(eventObj.ID, message, subject, attribute, timestamp, stopTime))
 		},
 	},