#12 Adding new import command and adjusting client

Author: lbroudoux

README.md

@@ -1,8 +1,9 @@
 # microcks-cli
+
 Simple CLI for interacting with Microcks server APIs.
-It allows to launch tests with minimal dependencies.
+It allows to launch tests or import API artifacts with minimal dependencies.
 
- [![Join the chat at https://gitter.im/microcks/microcks-cli](https://badges.gitter.im/microcks/microcks-cli.svg)](https://gitter.im/microcks/microcks-cli?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+ [![Join the chat on Zulip](https://img.shields.io/badge/chat-on_zulip-pink.svg?color=ff69b4&style=for-the-badge&logo=zulip)](https://microcksio.zulipchat.com/)
 
 ## Build Status
 
@@ -16,26 +17,29 @@ where `[command]` can be one of the following:
 * `version` to check this CLI version,
 * `help` to display usage informations,
 * `test` to launch new test on Microcks server.
+* `import` to import API artifacts on Microcks server.
+
+### Test command
 
-The main `test` command has a bunch of arguments and flags so that you can use it that way:
+The `test` command has a bunch of arguments and flags so that you can use it that way:
 ```
 microcks-cli test <apiName:apiVersion> <testEndpoint> <runner>
 	--microcksURL=<> --waitFor=5sec
 	--keycloakClientId=<> --keycloakClientSecret=<>
 ```
 
 The arguments:
-* `<apiName:apiVersion>` : Service to test reference. Exemple: `'Beer Catalog API:0.9'`
+* `<apiName:apiVersion>` : Service to test reference. Example: `'Beer Catalog API:0.9'`
 * `<testEndpoint>` : URL where is deployed implementation to test
-* `<runner>` : Test strategy (one of: `HTTP`, `SOAP`, `SOAP_UI`, `POSTMAN`, `OPEN_API_SCHEMA`, `ASYNC_API_SCHEMA`)")
+* `<runner>` : Test strategy (one of: `HTTP`, `SOAP`, `SOAP_UI`, `POSTMAN`, `OPEN_API_SCHEMA`, `ASYNC_API_SCHEMA`, `GRPC_PROTOBUF`)")
 
 The flags:
 * `--microcksURL` for the Microcks API endpoint,
 * `--waitFor` for the time to wait for test to finish (int + one of: milli, sec, min),
 * `--keycloakClientId` for the Keycloak Realm Service Account ClientId,
 * `--keycloakClientSecret` for the Keycloak Realm Service Account ClientSecret.
 
-Real life exemple command and execution:
+Real life example command and execution:
 ```
 $ ./microcks-cli test 'Beer Catalog API:0.9' http://localhost:9090/api/ POSTMAN \
         --microcksURL=http://localhost:8080/api/ \
@@ -48,7 +52,7 @@ MicrocksTester waiting for 2 seconds before checking again.
 MicrocksClient got status for test "5c1781cf6310d94f8169384e" - success: true, inProgress: false
 ```
 
-### Advanced options
+#### Advanced options
 
 The `test` command provides additional flags for advanced usages and options:
 * `--verbose` allows to dump on standard output all the HTTP requests and responses,
@@ -70,6 +74,41 @@ Here's below an example of using some of this flags:
         --operationsHeaders='{"globals": [{"name": "x-api-key", "values": "my-values"}], "GET /beer": [{"name": "x-trace-id", "values": "xcvbnsdfghjklm"}]}'
 ```
 
+### Import command
+
+The `import` command has one argument and common flags with `test` command. You can use it that way:
+```
+microcks-cli import <specificationFile1[:primary],specificationFile2[:primary]>
+	--microcksURL=<>
+	--keycloakClientId=<> --keycloakClientSecret=<>
+```
+
+The arguments:
+* `<specificationFile1[:primary],specificationFile2[:primary]>` : Comma separated list of API specs to import with flag telling if it's a primary artifact. Example: `'specs/my-openapi.yaml:true,specs/my-postmancollection.json:false'`
+
+The flags:
+* `--microcksURL` for the Microcks API endpoint,
+* `--keycloakClientId` for the Keycloak Realm Service Account ClientId,
+* `--keycloakClientSecret` for the Keycloak Realm Service Account ClientSecret.
+
+Real life example command and execution:
+```
+$ ./microcks-cli import 'samples/weather-forecast-openapi.yml:true,samples/weather-forecast-postman.json:false' \
+        --microcksURL=http://localhost:8080/api/ \
+        --keycloakClientId=microcks-serviceaccount \
+        --keycloakClientSecret=7deb71e8-8c80-4376-95ad-00a399ee3ca1
+Microcks has discovered 'WeatherForecast API:1.1.0'
+Microcks has discovered 'WeatherForecast API:1.1.0'
+```
+
+#### Advanced options
+
+The `import` command provides additional flags for advanced usages and options:
+* `--verbose` allows to dump on standard output all the HTTP requests and responses,
+* `--insecure` allows to interact with Microcks and Keycloak instances through HTTPS without checking certificates issuer CA,
+* `--caCerts=<path1,path2>` allows to specify additional certificates CRT files to add to trusted roots ones,
+
+
 ## Installation
 
 ### Binary
@@ -91,4 +130,4 @@ $ docker run -it quay.io/microcks/microcks-cli:latest microcks-cli test 'Beer Ca
 
 ## Tekton tasks
 
-This repository also contains different [Tekton](https://tekton.dev/) tasks definition and sample pipelines. You'll find under the `/tekton` folder the resource for current `v1beta1` Tekton API version and the older `v1alpha1` under `tekton/v1alpha1`.
+This repository also contains different [Tekton](https://tekton.dev/) tasks definition and sample pipelines. You'll find under the `/tekton` folder the resource for current `v1beta1` Tekton API version and the older `v1alpha1` under `tekton/v1alpha1`.

cmd/help.go

@@ -14,7 +14,7 @@ func NewHelpCommand() Command {
 func (c *helpCommand) Execute() {
 	fmt.Println("")
 	fmt.Println("microcks-cli is a CLI for interacting with Microcks server APIs.")
-	fmt.Println("It allows to launch tests with minimal dependencies")
+	fmt.Println("It allows to launch tests or import API artifacts with minimal dependencies")
 	fmt.Println("")
 	fmt.Println("")
 	fmt.Println("Usage:")
@@ -24,6 +24,7 @@ func (c *helpCommand) Execute() {
 	fmt.Println("  version     check this CLI version")
 	fmt.Println("  help        display this help message")
 	fmt.Println("  test        launch new test on Microcks server")
+	fmt.Println("  import      import API artifacts on Microcks server")
 	fmt.Println("")
 	fmt.Println("Use: microcks-cli test <apiName:apiVersion> <testEndpoint> <runner> \\")
 	fmt.Println("   --microcksURL=<> --waitFor=5sec \\")
@@ -40,4 +41,17 @@ func (c *helpCommand) Execute() {
 	fmt.Println("  --keycloakClientId     Keycloak Realm Service Account ClientId")
 	fmt.Println("  --keycloakClientSecret Keycloak Realm Service Account ClientSecret")
 	fmt.Println("")
+	fmt.Println("")
+	fmt.Println("Use: microcks-cli import <specificationFile1[:primary],specificationFile2[:primary]> \\")
+	fmt.Println("   --microcksURL=<> \\")
+	fmt.Println("   --keycloakClientId=<> --keycloakClientSecret=<>")
+	fmt.Println("")
+	fmt.Println("Args: ")
+	fmt.Println("  <specificationFile1[:primary],specificationFile2[:primary]>   Exemple: 'specs/my-openapi.yaml:true,specs/my-postmancollection.json:false'")
+	fmt.Println("")
+	fmt.Println("Flags: ")
+	fmt.Println("  --microcksURL          Microcks API endpoint")
+	fmt.Println("  --keycloakClientId     Keycloak Realm Service Account ClientId")
+	fmt.Println("  --keycloakClientSecret Keycloak Realm Service Account ClientSecret")
+	fmt.Println("")
 }

cmd/import.go

@@ -0,0 +1,123 @@
+package cmd
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+
+	"github.com/microcks/microcks-cli/pkg/config"
+	"github.com/microcks/microcks-cli/pkg/connectors"
+)
+
+type importComamnd struct {
+}
+
+// NewImportCommand build a new ImportCommand implementation
+func NewImportCommand() Command {
+	return new(importComamnd)
+}
+
+// Execute implementation of importComamnd structure
+func (c *importComamnd) Execute() {
+
+	// Parse subcommand args first.
+	if len(os.Args) < 2 {
+		fmt.Println("import command require <specificationFile1[:primary],specificationFile2[:primary]> args")
+		os.Exit(1)
+	}
+
+	specificationFiles := os.Args[2]
+
+	// Then parse flags.
+	importCmd := flag.NewFlagSet("import", flag.ExitOnError)
+
+	var microcksURL string
+	var keycloakURL string
+	var keycloakClientID string
+	var keycloakClientSecret string
+	var insecureTLS bool
+	var caCertPaths string
+	var verbose bool
+
+	importCmd.StringVar(&microcksURL, "microcksURL", "", "Microcks API URL")
+	importCmd.StringVar(&keycloakClientID, "keycloakClientId", "", "Keycloak Realm Service Account ClientId")
+	importCmd.StringVar(&keycloakClientSecret, "keycloakClientSecret", "", "Keycloak Realm Service Account ClientSecret")
+	importCmd.BoolVar(&insecureTLS, "insecure", false, "Whether to accept insecure HTTPS connection")
+	importCmd.StringVar(&caCertPaths, "caCerts", "", "Comma separated paths of CRT files to add to Root CAs")
+	importCmd.BoolVar(&verbose, "verbose", false, "Produce dumps of HTTP exchanges")
+	importCmd.Parse(os.Args[3:])
+
+	// Validate presence and values of flags.
+	if len(microcksURL) == 0 {
+		fmt.Println("--microcksURL flag is mandatory. Check Usage.")
+		os.Exit(1)
+	}
+	if len(keycloakClientID) == 0 {
+		fmt.Println("--keycloakClientId flag is mandatory. Check Usage.")
+		os.Exit(1)
+	}
+	if len(keycloakClientSecret) == 0 {
+		fmt.Println("--keycloakClientSecret flag is mandatory. Check Usage.")
+		os.Exit(1)
+	}
+
+	// Collect optional HTTPS transport flags.
+	if insecureTLS {
+		config.InsecureTLS = true
+	}
+	if len(caCertPaths) > 0 {
+		config.CaCertPaths = caCertPaths
+	}
+	if verbose {
+		config.Verbose = true
+	}
+
+	//
+
+	// Now we seems to be good ...
+	// First - retrieve the Keycloak URL from Microcks configuration.
+	mc := connectors.NewMicrocksClient(microcksURL)
+	keycloakURL, err := mc.GetKeycloakURL()
+	if err != nil {
+		fmt.Printf("Got error when invoking Microcks client retrieving config: %s", err)
+		os.Exit(1)
+	}
+
+	// Second - retrieve an OAuth token using Keycloak Client.
+	kc := connectors.NewKeycloakClient(keycloakURL, keycloakClientID, keycloakClientSecret)
+
+	var oauthToken string
+	oauthToken, err = kc.ConnectAndGetToken()
+	if err != nil {
+		fmt.Printf("Got error when invoking Keycloack client: %s", err)
+		os.Exit(1)
+	}
+
+	// Then - for each specificationFile, upload the artifact on Microcks Server.
+	mc.SetOAuthToken(oauthToken)
+
+	sepSpecificationFiles := strings.Split(specificationFiles, ",")
+	for _, f := range sepSpecificationFiles {
+		mainArtifact := true
+
+		// Check if mainArtifact flag is provided.
+		if strings.Contains(f, ":") {
+			pathAndMainArtifact := strings.Split(f, ":")
+			f = pathAndMainArtifact[0]
+			mainArtifact, err = strconv.ParseBool(pathAndMainArtifact[1])
+			if err != nil {
+				fmt.Printf("Cannot parse '%s' as Bool, default to true\n", pathAndMainArtifact[1])
+			}
+		}
+
+		// Try uploading this artifact.
+		msg, err := mc.UploadArtifact(f, mainArtifact)
+		if err != nil {
+			fmt.Printf("Got error when invoking Microcks client importing Artifact: %s", err)
+			os.Exit(1)
+		}
+		fmt.Printf("Microcks has discovered '%s'\n", msg)
+	}
+}

cmd/version.go

@@ -12,5 +12,5 @@ func NewVersionCommand() Command {
 
 // Execute implementation on versionCommand structure
 func (c *versionCommand) Execute() {
-	fmt.Println("0.3.0")
+	fmt.Println("0.4.0")
 }

main.go

@@ -21,6 +21,8 @@ func main() {
 		c = cmd.NewHelpCommand()
 	case "test":
 		c = cmd.NewTestCommand()
+	case "import":
+		c = cmd.NewImportCommand()
 	default:
 		cmd.NewHelpCommand().Execute()
 		os.Exit(1)

pkg/connectors/microcks_client.go

@@ -1,11 +1,16 @@
 package connectors
 
 import (
+	"bytes"
 	"encoding/json"
 	"fmt"
+	"io"
 	"io/ioutil"
+	"mime/multipart"
 	"net/http"
 	"net/url"
+	"os"
+	"path/filepath"
 	"strconv"
 	"strings"
 
@@ -16,8 +21,9 @@ import (
 type MicrocksClient interface {
 	GetKeycloakURL() (string, error)
 	SetOAuthToken(oauthToken string)
-	CreateTestResult(serviceID string, testEndpoint string, runnerType string, secretName string, timeout int64, soperationsHeaders string) (string, error)
+	CreateTestResult(serviceID string, testEndpoint string, runnerType string, secretName string, timeout int64, operationsHeaders string) (string, error)
 	GetTestResult(testResultID string) (*TestResultSummary, error)
+	UploadArtifact(specificationFilePath string, mainArtifact bool) (string, error)
 }
 
 // TestResultSummary represents a simple view on Microcks TestResult
@@ -199,6 +205,65 @@ func (c *microcksClient) GetTestResult(testResultID string) (*TestResultSummary,
 	return &result, err
 }
 
+func (c *microcksClient) UploadArtifact(specificationFilePath string, mainArtifact bool) (string, error) {
+	// Ensure file exists on fs.
+	file, err := os.Open(specificationFilePath)
+	if err != nil {
+		return "", err
+	}
+	defer file.Close()
+
+	// Create a multipart request body, reading the file.
+	body := &bytes.Buffer{}
+	writer := multipart.NewWriter(body)
+	part, err := writer.CreateFormFile("file", filepath.Base(specificationFilePath))
+	if err != nil {
+		return "", err
+	}
+	_, err = io.Copy(part, file)
+	if err != nil {
+		panic(err.Error())
+	}
+
+	// Add the mainArtifact flag to request.
+	_ = writer.WriteField("mainArtifact", strconv.FormatBool(mainArtifact))
+
+	err = writer.Close()
+	if err != nil {
+		return "", err
+	}
+
+	// Ensure we have a correct URL.
+	rel := &url.URL{Path: "artifact/upload"}
+	u := c.APIURL.ResolveReference(rel)
+
+	req, err := http.NewRequest("POST", u.String(), body)
+	if err != nil {
+		return "", err
+	}
+	req.Header.Set("Content-Type", writer.FormDataContentType())
+	req.Header.Set("Authorization", "Bearer "+c.OAuthToken)
+
+	// Dump request if verbose required.
+	config.DumpRequestIfRequired("Microcks for uploading artifact", req, true)
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+
+	// Dump response if verbose required.
+	config.DumpResponseIfRequired("Microcks for uploading artifact", resp, true)
+
+	respBody, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		panic(err.Error())
+	}
+
+	return string(respBody), err
+}
+
 func ensureValid(operationsHeaders string) bool {
 	// Unmarshal using a generic interface
 	var headers = map[string][]HeaderDTO{}