fix: Use artifact as key of config

zeppelin-server/src/main/java/org/apache/zeppelin/rest/HeliumRestApi.java

@@ -195,7 +195,7 @@ public class HeliumRestApi {
   @Path("config")
   public Response getAllPackageConfigs() {
     try {
-      Map<String, Map<String, Map<String, Object>>> config = helium.getAllPackageConfig();
+      Map<String, Map<String, Object>> config = helium.getAllPackageConfig();
       return new JsonResponse(Response.Status.OK, config).build();
     } catch (RuntimeException e) {
       logger.error(e.getMessage(), e);
@@ -204,18 +204,17 @@ public class HeliumRestApi {
   }
 
   @GET
-  @Path("config/{packageName}/{packageVersion}")
-  public Response getPackageConfig(@PathParam("packageName") String packageName,
-                                   @PathParam("packageVersion") String packageVersion) {
+  @Path("config/{artifact}")
+  public Response getPackageConfig(@PathParam("artifact") String artifact) {
 
-    if (StringUtils.isEmpty(packageName) || StringUtils.isEmpty(packageVersion)) {
+    if (StringUtils.isEmpty(artifact)) {
       return new JsonResponse(Response.Status.BAD_REQUEST,
           "package name or version is empty"
       ).build();
     }
 
     try {
-      Map<String, Object> config = helium.getPackageConfig(packageName, packageVersion);
+      Map<String, Object> config = helium.getPackageConfig(artifact);
       return new JsonResponse(Response.Status.OK, config).build();
     } catch (RuntimeException e) {
       logger.error(e.getMessage(), e);
@@ -224,9 +223,8 @@ public class HeliumRestApi {
   }
 
   @POST
-  @Path("config/{packageName}/{packageVersion}")
-  public Response updatePackageConfig(@PathParam("packageName") String packageName,
-                                      @PathParam("packageVersion") String packageVersion,
+  @Path("config/{artifact}")
+  public Response updatePackageConfig(@PathParam("artifact") String artifact,
                                       String rawConfig) {
 
     Map<String, Object> packageConfig = null;
@@ -234,7 +232,7 @@ public class HeliumRestApi {
     try {
       packageConfig = gson.fromJson(
           rawConfig, new TypeToken<Map<String, Object>>(){}.getType());
-      helium.updatePackageConfig(packageName, packageVersion, packageConfig);
+      helium.updatePackageConfig(artifact, packageConfig);
     } catch (JsonParseException e) {
       logger.error(e.getMessage(), e);
       return new JsonResponse(Response.Status.BAD_REQUEST,

zeppelin-web/src/app/helium/helium.controller.js

@@ -211,16 +211,10 @@ export default function HeliumCtrl($scope, $rootScope, $sce,
 
     const pkg = pkgSearchResult.pkg;
     const pkgName = pkg.name;
-    const pkgVersion = pkg.version;
 
-    if (!pkgName || !pkgVersion) {
-      console.error(`Failed to fetch config for '${pkgSearchResult}@${pkgVersion}'`);
-      return;
-    }
-
-    heliumService.getSinglePackageConfigs(pkgName, pkgVersion)
-      .then(conf => {
-        $scope.defaultPackageConfigs[pkgName] = conf;
+    heliumService.getSinglePackageConfigs(pkg)
+      .then(confs => {
+        $scope.defaultPackageConfigs[pkgName] = confs;
         pkgSearchResult.configOpened = true;
         $scope.$digest(); // to trigger view update
       });
@@ -228,10 +222,9 @@ export default function HeliumCtrl($scope, $rootScope, $sce,
 
   $scope.saveConfig = function(pkgSearchResult) {
     const pkgName = pkgSearchResult.pkg.name;
-    const pkgVersion = pkgSearchResult.pkg.version;
     const currentConf = $scope.defaultPackageConfigs[pkgName];
 
-    heliumService.saveConfig(pkgName, pkgVersion, currentConf);
+    heliumService.saveConfig(pkgSearchResult.pkg, currentConf);
   };
 
   init();

zeppelin-web/src/components/helium/helium-conf.js

@@ -65,9 +65,12 @@ export function createAllPackageConfigs(defaultPackages, persistedConfs) {
     const version = pkgSearchResult.pkg.version;
     if (!version) { continue; }
 
+    const artifact = pkgSearchResult.pkg.artifact;
+    if (!artifact) { continue; }
+
     let persistedConf = {};
-    if (persistedConfs[name] && persistedConfs[name][version]) {
-      persistedConf = persistedConfs[name][version];
+    if (persistedConfs[artifact]) {
+      persistedConf = persistedConfs[artifact];
     }
 
     const confs = mergePersistedConfWithSpec(persistedConf, spec);
@@ -106,5 +109,3 @@ export function createPersistableConfig(currentConfs) {
 
   return filtered;
 }
-
-

zeppelin-web/src/components/helium/helium.service.js

@@ -129,16 +129,20 @@ export default function heliumService($http, $sce, baseUrlSrv) {
     return $http.post(baseUrlSrv.getRestApiBase() + '/helium/disable/' + name);
   };
 
-  this.saveConfig = function(pkgName, pkgVersion, defaultPackageConfig) {
+  this.saveConfig = function(pkg , defaultPackageConfig) {
+    let pkgArtifact = pkg.artifact;
     const filtered = createPersistableConfig(defaultPackageConfig);
 
-    if (!pkgName || !pkgVersion || !filtered) {
+    if (!pkgArtifact|| !filtered) {
       console.error(
-        `Can't save helium package '${pkgName}@${pkgVersion}' config`, filtered);
+        `Can't save config for helium package '${pkgArtifact}'`, filtered);
       return;
     }
 
-    const url = `${baseUrlSrv.getRestApiBase()}/helium/config/${pkgName}/${pkgVersion}`;
+    // in case of local package, it will include `/`
+    pkgArtifact = encodeURIComponent(pkgArtifact);
+
+    const url = `${baseUrlSrv.getRestApiBase()}/helium/config/${pkgArtifact}`;
     return $http.post(url, filtered);
   };
 
@@ -219,10 +223,22 @@ export default function heliumService($http, $sce, baseUrlSrv) {
    * get the package config which is persisted in server.
    * @return { Promise<Array<Object>> }
    */
-  this.getSinglePackageConfigs = function(pkgName, pkgVersion) {
+  this.getSinglePackageConfigs = function(pkg) {
+    const pkgName = pkg.name;
+    const pkgVersion = pkg.version;
+    let pkgArtifact = pkg.artifact;
+
+    if (!pkgName || !pkgVersion || !pkgArtifact) {
+      console.error(`Failed to fetch config for \n`, pkg);
+      return;
+    }
+
     const promisedPkgSearchResult = this.getSinglePackageInfo(pkgName, pkgVersion);
 
-    const confUrl = `${baseUrlSrv.getRestApiBase()}/helium/config/${pkgName}/${pkgVersion}`;
+    // in case of local package, it will include `/`
+    pkgArtifact = encodeURIComponent(pkgArtifact);
+
+    const confUrl = `${baseUrlSrv.getRestApiBase()}/helium/config/${pkgArtifact}`;
     const promisedConf = $http.get(confUrl)
       .then(function(response, status) {
         return response.data.body;
@@ -246,15 +262,11 @@ export default function heliumService($http, $sce, baseUrlSrv) {
       .then(defaultPackages => {
         const pkgSearchResult = findPackageByMagic(defaultPackages, magic)
 
-        // return empty conf if failed to find pkg
+        // return empty confs if failed to find pkg
         if (!pkgSearchResult) {
-          return {};
+          return [];
         }
-
-        const pkgVersion = pkgSearchResult.pkg.version;
-        const pkgName = pkgSearchResult.pkg.name;
-
-        return this.getSinglePackageConfigs(pkgName, pkgVersion);
+        return this.getSinglePackageConfigs(pkgSearchResult.pkg);
       });
 
     return promised;

zeppelin-zengine/src/main/java/org/apache/zeppelin/helium/Helium.java

@@ -304,19 +304,19 @@ public class Helium {
     save();
   }
 
-  public void updatePackageConfig(String pkgName, String pkgVersion,
-                                  Map<String, Object> pkgConfig) throws IOException {
-    heliumConf.updatePackageConfig(pkgName, pkgVersion, pkgConfig);
+  public void updatePackageConfig(String artifact, Map<String, Object> pkgConfig)
+      throws IOException {
 
+    heliumConf.updatePackageConfig(artifact, pkgConfig);
     save();
   }
 
-  public Map<String, Map<String, Map<String, Object>>> getAllPackageConfig() {
+  public Map<String, Map<String, Object>> getAllPackageConfig() {
     return heliumConf.getAllPackageConfigs();
   }
 
-  public Map<String, Object> getPackageConfig(String pkgName, String pkgVersion) {
-    return heliumConf.getPackageConfig(pkgName, pkgVersion);
+  public Map<String, Object> getPackageConfig(String artifact) {
+    return heliumConf.getPackageConfig(artifact);
   }
 
   public HeliumPackageSuggestion suggestApp(Paragraph paragraph) {

zeppelin-zengine/src/main/java/org/apache/zeppelin/helium/HeliumConf.java

@@ -25,10 +25,10 @@ public class HeliumConf {
   // enabled packages {name, version}
   private Map<String, String> enabled = Collections.synchronizedMap(new HashMap<String, String>());
 
-  // config for versioned package {name {version {configKey configValue}}}
-  private Map<String, Map<String, Map<String, Object>>> packageConfig =
+  // {artifact, {configKey, configValue}}
+  private Map<String, Map<String, Object>> packageConfig =
       Collections.synchronizedMap(
-          new HashMap<String, Map<String, Map<String, Object>>>());
+          new HashMap<String, Map<String, Object>>());
 
   // enabled visualization package display order
   private List<String> bundleDisplayOrder = new LinkedList<>();
@@ -45,41 +45,30 @@ public class HeliumConf {
     enabled.put(name, artifact);
   }
 
-  public void updatePackageConfig(String pkgName, String pkgVersion,
+  public void updatePackageConfig(String artifact,
                                   Map<String, Object> newConfig) {
-    if (!packageConfig.containsKey(pkgName)) {
-      packageConfig.put(pkgName,
-          Collections.synchronizedMap(new HashMap<String, Map<String, Object>>()));
-    }
-
-    Map<String, Map<String, Object>> versionedConfig = packageConfig.get(pkgName);
-
-    versionedConfig.put(pkgVersion, newConfig);
-  }
-
-  /**
-   * @return versioned package config `{name, {version, {configKey, configVal}}}`
-   */
-  public Map<String, Map<String, Map<String, Object>>> getAllPackageConfigs () {
-    return packageConfig;
-  }
-
-  public Map<String, Object> getPackageConfig (String pkgName, String pkgVersion) {
-    if (!packageConfig.containsKey(pkgName)) {
-      packageConfig.put(pkgName,
-          Collections.synchronizedMap(new HashMap<String, Map<String, Object>>()));
-    }
-
-    Map<String, Map<String, Object>> versionedConfig = packageConfig.get(pkgName);
-
-    if (!versionedConfig.containsKey(pkgVersion)) {
-      versionedConfig.put(pkgVersion,
+    if (!packageConfig.containsKey(artifact)) {
+      packageConfig.put(artifact,
           Collections.synchronizedMap(new HashMap<String, Object>()));
     }
 
-    Map<String, Object> config = versionedConfig.get(pkgVersion);
+    packageConfig.put(artifact, newConfig);
+  }
 
-    return config;
+  /**
+   * @return versioned package config `{artifact, {configKey, configVal}}`
+   */
+  public Map<String, Map<String, Object>> getAllPackageConfigs () {
+    return packageConfig;
+  }
+
+  public Map<String, Object> getPackageConfig (String artifact) {
+    if (!packageConfig.containsKey(artifact)) {
+      packageConfig.put(artifact,
+          Collections.synchronizedMap(new HashMap<String, Object>()));
+    }
+
+    return packageConfig.get(artifact);
   }
 
   public void disablePackage(HeliumPackage pkg) {