App import (#309)

* Add base url method, fixed meta-url bug
* Added import command

.gitignore

@@ -2,7 +2,6 @@
 vendor/
 .vscode/
 .DS_Store
-*.qvf
 *.exe
 corectl
 corectl.exe

cmd/app.go

@@ -9,7 +9,7 @@ import (
 	"github.com/spf13/viper"
 )
 
-var getAppsCmd = &cobra.Command{
+var listAppsCmd = &cobra.Command{
 	Use:     "ls",
 	Args:    cobra.ExactArgs(0),
 	Short:   "Print a list of all apps available in the current engine",
@@ -47,6 +47,23 @@ var removeAppCmd = withLocalFlags(&cobra.Command{
 	},
 }, "suppress")
 
+var importAppCmd = &cobra.Command{
+	Use:			"import",
+	Args:			cobra.ExactArgs(1),
+	Short:		"Import the specified app into the engine, returns the ID of the created app",
+	Long:			"Import the specified app into the engine, returns the ID of the created app",
+	Example:	"corectl import <path-to-app.qvf>",
+	Annotations: map[string]string{
+		"x-qlik-stability": "experimental",
+	},
+
+	Run: func(ccmd *cobra.Command, args []string) {
+		appPath := args[0]
+		appID := internal.ImportApp(appPath, viper.GetString("engine"), headers)
+		fmt.Println("Imported app with new ID: " + appID)
+	},
+}
+
 var appCmd = &cobra.Command{
 	Use:   "app",
 	Short: "Explore and manage apps",
@@ -57,5 +74,5 @@ var appCmd = &cobra.Command{
 }
 
 func init() {
-	appCmd.AddCommand(getAppsCmd, removeAppCmd)
+	appCmd.AddCommand(listAppsCmd, removeAppCmd, importAppCmd)
 }

docs/corectl_app.md

@@ -30,6 +30,7 @@ Explore and manage apps
 ### SEE ALSO
 
 * [corectl](corectl.md)	 - 
+* [corectl app import](corectl_app_import.md)	 - Import the specified app into the engine, returns the ID of the created app
 * [corectl app ls](corectl_app_ls.md)	 - Print a list of all apps available in the current engine
 * [corectl app rm](corectl_app_rm.md)	 - Remove the specified app
 

docs/corectl_app_import.md

@@ -0,0 +1,43 @@
+## corectl app import
+
+Import the specified app into the engine, returns the ID of the created app
+
+### Synopsis
+
+Import the specified app into the engine, returns the ID of the created app
+
+```
+corectl app import [flags]
+```
+
+### Examples
+
+```
+corectl import <path-to-app.qvf>
+```
+
+### Options
+
+```
+  -h, --help   help for import
+```
+
+### Options inherited from parent commands
+
+```
+  -a, --app string               Name or identifier of the app
+      --certificates string      path/to/folder containing client.pem, client_key.pem and root.pem certificates
+  -c, --config string            path/to/config.yml where parameters can be set instead of on the command line
+  -e, --engine string            URL to the Qlik Associative Engine (default "localhost:9076")
+      --headers stringToString   Http headers to use when connecting to Qlik Associative Engine (default [])
+      --json                     Returns output in JSON format if possible, disables verbose and traffic output
+      --no-data                  Open app without data
+  -t, --traffic                  Log JSON websocket traffic to stdout
+      --ttl string               Qlik Associative Engine session time to live in seconds (default "0")
+  -v, --verbose                  Log extra information
+```
+
+### SEE ALSO
+
+* [corectl app](corectl_app.md)	 - Explore and manage apps
+

docs/spec.json

@@ -60,6 +60,10 @@
     "app": {
       "description": "Explore and manage apps",
       "commands": {
+        "import": {
+          "description": "Import the specified app into the engine, returns the ID of the created app",
+          "x-qlik-stability": "experimental"
+        },
         "ls": {
           "description": "Print a list of all apps available in the current engine"
         },

internal/restapi.go

@@ -5,6 +5,8 @@ import (
 	"fmt"
 	"io/ioutil"
 	"net/http"
+	neturl "net/url"
+	"os"
 )
 
 // ReadRestMetadata fetches metadata from the rest api.
@@ -33,6 +35,41 @@ func ReadRestMetadata(url string, headers http.Header) (*RestMetadata, error) {
 	return result, nil
 }
 
+func ImportApp(appPath, engine string, headers http.Header) string {
+	url, err := neturl.Parse(buildRestBaseURL(engine))
+	url.Path = "/v1/apps/import"
+	// You can specify name and mode with query but they only seem to work in ABAC mode.
+	values := neturl.Values{}
+	url.RawQuery = values.Encode()
+	file, err := os.Open(appPath)
+	if err != nil {
+		FatalError("could not open file: ", appPath)
+	}
+	defer file.Close()
+	req, err := http.NewRequest("POST", url.String(), file)
+	if err != nil {
+		FatalError(err)
+	}
+	req.Header = headers
+	req.Header.Add("Content-Type", "binary/octet-stream")
+	response, err := http.DefaultClient.Do(req)
+	if err != nil {
+		FatalError(err)
+	}
+	defer response.Body.Close()
+	data, _ := ioutil.ReadAll(response.Body)
+	if response.StatusCode != 200 {
+		FatalErrorf("could not import app: got status %d with message %s",
+			response.StatusCode, string(data))
+	}
+	appInfo := &RestNxApp{}
+	json.Unmarshal(data, appInfo)
+	appID := appInfo.Attributes["id"]
+	appName := appInfo.Attributes["name"]
+	setAppIDToKnownApps(engine, appName, appID, false)
+	return appID
+}
+
 func toFieldMetadataMap(fields []*RestFieldMetadata) map[string]*RestFieldMetadata {
 	result := make(map[string]*RestFieldMetadata)
 	for _, field := range fields {
@@ -131,3 +168,7 @@ type RestFieldMetadata struct {
 	// Static RAM memory used in bytes.
 	ByteSize int `json:"byte_size"`
 }
+
+type RestNxApp struct {
+	Attributes map[string]string `json:"attributes"`
+}

internal/state.go

@@ -258,10 +258,16 @@ func buildWebSocketURL(engine string, ttl string) string {
 	return engine
 }
 
+func buildRestBaseURL(engine string) string {
+	engineURL := TidyUpEngineURL(engine)
+	u, _ := neturl.Parse(engineURL)
+	// u.Scheme[2:] is "" for ws and s for wss
+	baseURL := "http" + u.Scheme[2:] + "://" + u.Host
+	return baseURL
+}
+
 func buildMetadataURL(engine string, appID string) string {
-	engine = TidyUpEngineURL(engine)
-	engine = strings.Replace(engine, "wss://", "https://", -1)
-	engine = strings.Replace(engine, "ws://", "http://", -1)
+	engine = buildRestBaseURL(engine)
 	url := fmt.Sprintf("%s/v1/apps/%s/data/metadata", engine, neturl.QueryEscape(appID))
 	return url
 }

internal/state_test.go

@@ -6,13 +6,24 @@ import (
 	"github.com/magiconair/properties/assert"
 )
 
+func TestBuildRestBaseUrl(t *testing.T) {
+	assert.Equal(t, buildRestBaseURL("engine"), "http://engine")
+	assert.Equal(t, buildRestBaseURL("engine.com"), "http://engine.com")
+	assert.Equal(t, buildRestBaseURL("engine.com/app/appId"), "http://engine.com")
+	assert.Equal(t, buildRestBaseURL("engine:1234"), "http://engine:1234")
+	assert.Equal(t, buildRestBaseURL("ws://engine:1234"), "http://engine:1234")
+	assert.Equal(t, buildRestBaseURL("wss://engine:1234"), "https://engine:1234")
+	assert.Equal(t, buildRestBaseURL("wss://engine:1234/app/appId"), "https://engine:1234")
+}
+
 func TestBuildMetaUrl(t *testing.T) {
 	assert.Equal(t, buildMetadataURL("engine", "appId"), "http://engine/v1/apps/appId/data/metadata")
 	assert.Equal(t, buildMetadataURL("engine:1234", "appId"), "http://engine:1234/v1/apps/appId/data/metadata")
 	assert.Equal(t, buildMetadataURL("wss://engine", "appId"), "https://engine/v1/apps/appId/data/metadata")
 	assert.Equal(t, buildMetadataURL("ws://engine", "appId"), "http://engine/v1/apps/appId/data/metadata")
 	assert.Equal(t, buildMetadataURL("wss://engine:1234", "appId"), "https://engine:1234/v1/apps/appId/data/metadata")
 	assert.Equal(t, buildMetadataURL("ws://engine:1234", "appId"), "http://engine:1234/v1/apps/appId/data/metadata")
+	assert.Equal(t, buildMetadataURL("ws://engine:1234/app/appId", "appId"), "http://engine:1234/v1/apps/appId/data/metadata")
 }
 
 func TestBuildEngineUrl(t *testing.T) {

test/corectl_integration_test.go

@@ -6,6 +6,7 @@ import (
 	"github.com/qlik-oss/corectl/test/toolkit"
 	"os"
 	"testing"
+	"strings"
 )
 
 func TestBasicAnalyzing(t *testing.T) {
@@ -392,5 +393,24 @@ func TestCommandLineOverridingConfigFile(t *testing.T) {
 	p2.ExpectJsonArray("qId", "swedish-dimension").Run("dimension", "ls", "--json")
 	p2.ExpectJsonArray("qId", "measure-x").Run("measure", "ls", "--json")
 	p2.ExpectJsonArray("qName", "bogusname").Run("connection", "ls", "--json")
+}
 
+func TestImportApp(t *testing.T) {
+	parseID := func (output []byte) string {
+		appID := strings.Split(string(output), ": ")[1]
+		return strings.TrimSpace(appID)
+	}
+	// Create tests for the standard, abac and jwt case.
+	pStd := toolkit.Params{T: t, Engine: *toolkit.EngineStdIP}
+	pAbac := toolkit.Params{T: t, Engine: *toolkit.EngineAbacIP}
+	pJwt := toolkit.Params{T: t, Engine: *toolkit.EngineJwtIP, Config: "test/projects/using-jwts/corectl.yml"}
+	params := []toolkit.Params{pStd, pAbac, pJwt}
+	for _, p := range params {
+		// See if we can import the app test.qvf
+		output := p.ExpectOK().Run("app", "import", "test/projects/import/test.qvf")
+		appID := parseID(output)
+		// If it was created, we can remove it
+		p.ExpectOK().Run("app", "rm", appID, "--suppress")
+		p.Reset()
+	}
 }