Modified: zeppelin/site/docs/0.8.0-SNAPSHOT/search_data.json
URL: 
http://svn.apache.org/viewvc/zeppelin/site/docs/0.8.0-SNAPSHOT/search_data.json?rev=1800233&r1=1800232&r2=1800233&view=diff
==============================================================================
--- zeppelin/site/docs/0.8.0-SNAPSHOT/search_data.json (original)
+++ zeppelin/site/docs/0.8.0-SNAPSHOT/search_data.json Thu Jun 29 06:33:24 2017
@@ -3,214 +3,104 @@
   
   
 
-    "/development/howtocontribute.html": {
+    "/development/contribution/how_to_contribute_code.html": {
       "title": "Contributing to Apache Zeppelin (Code)",
       "content"  : "<!--Licensed under the Apache License, Version 2.0 (the 
"License");you may not use this file except in compliance with the 
License.You may obtain a copy of the License 
athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law 
or agreed to in writing, softwaredistributed under the License is distributed 
on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, 
either express or implied.See the License for the specific language governing 
permissions andlimitations under the License.-->Contributing to Apache 
Zeppelin ( Code )NOTE : Apache Zeppelin is an Apache2 License Software.Any 
contributions to Zeppelin (Source code, Documents, Image, Website) means you 
agree with license all your contributions as Apache2 License.Setting upHere are 
some tools you will need to build and test Zeppelin.Software Configuration 
Management ( SCM )Since Zeppelin uses Git for it's SCM system, you need 
git client installed in y
 our development machine.Integrated Development Environment ( IDE )You are free 
to use whatever IDE you prefer, or your favorite command line editor.Build 
ToolsTo build the code, installOracle Java 7Apache MavenGetting the source 
codeFirst of all, you need Zeppelin source code. The official location of 
Zeppelin is http://git.apache.org/zeppelin.git.git accessGet the source code on 
your development machine using git.git clone git://git.apache.org/zeppelin.git 
zeppelinYou may also want to develop against a specific branch. For example, 
for branch-0.5.6git clone -b branch-0.5.6 git://git.apache.org/zeppelin.git 
zeppelinApache Zeppelin follows Fork & Pull as a source control 
workflow.If you want to not only build Zeppelin but also make any changes, then 
you need to fork Zeppelin github mirror repository and make a pull 
request.Before making a pull request, please take a look Contribution 
Guidelines.Buildmvn installTo skip testmvn install -DskipTestsTo build with 
specific spark / 
 hadoop versionmvn install -Dspark.version=x.x.x -Dhadoop.version=x.x.xFor the 
further Run Zeppelin server in development modecd 
zeppelin-serverHADOOP_HOME=YOUR_HADOOP_HOME JAVA_HOME=YOUR_JAVA_HOME mvn 
exec:java 
-Dexec.mainClass="org.apache.zeppelin.server.ZeppelinServer" 
-Dexec.args=""Note: Make sure you first run mvn clean install 
-DskipTests on your zeppelin root directory, otherwise your server build will 
fail to find the required dependencies in the local repro.or use daemon 
scriptbin/zeppelin-daemon startServer will be run on 
http://localhost:8080.Generating Thrift CodeSome portions of the Zeppelin code 
are generated by Thrift. For most Zeppelin changes, you don't need to 
worry about this. But if you modify any of the Thrift IDL files (e.g. 
zeppelin-interpreter/src/main/thrift/*.thrift), then you also need to 
regenerate these files and submit their updated version as part of your 
patch.To regenerate the code, install thrift-0.9.2 and 
 then run the following command to generate thrift code.cd 
<zeppelin_home>/zeppelin-interpreter/src/main/thrift./genthrift.shRun
 Selenium testZeppelin has set of integration tests using Selenium. To run 
these test, first build and run Zeppelin and make sure Zeppelin is running on 
port 8080. Then you can run test using following commandTEST_SELENIUM=true mvn 
test -Dtest=[TEST_NAME] -DfailIfNoTests=false -pl 
'zeppelin-interpreter,zeppelin-zengine,zeppelin-server'For 
example, to run ParagraphActionIT,TEST_SELENIUM=true mvn test 
-Dtest=ParagraphActionsIT -DfailIfNoTests=false -pl 
'zeppelin-interpreter,zeppelin-zengine,zeppelin-server'You'll
 need Firefox web browser installed in your development environment. While CI 
server uses Firefox 31.0 to run selenium test, it is good idea to install the 
same version (disable auto update to keep the version).Where to StartYou can 
find issues for beginner & newbieStay involvedContributors 
 should join the Zeppelin mailing lists....@zeppelin.apache.org is for people 
who want to contribute code to Zeppelin. subscribe, unsubscribe, archivesIf you 
have any issues, create a ticket in JIRA.",
-      "url": " /development/howtocontribute.html",
-      "group": "development",
+      "url": " /development/contribution/how_to_contribute_code.html",
+      "group": "development/contribution",
       "excerpt": "How can you contribute to Apache Zeppelin project? This 
document covers from setting up your develop environment to making a pull 
request on Github."
     }
     ,
     
   
 
-    "/development/howtocontributewebsite.html": {
+    "/development/contribution/how_to_contribute_website.html": {
       "title": "Contributing to Apache Zeppelin (Website)",
       "content"  : "<!--Licensed under the Apache License, Version 2.0 (the 
"License");you may not use this file except in compliance with the 
License.You may obtain a copy of the License 
athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law 
or agreed to in writing, softwaredistributed under the License is distributed 
on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, 
either express or implied.See the License for the specific language governing 
permissions andlimitations under the License.-->Contributing to Apache 
Zeppelin ( Website )This page will give you an overview of how to build and 
contribute to the documentation of Apache Zeppelin.The online documentation at 
zeppelin.apache.org is also generated from the files found here.NOTE : Apache 
Zeppelin is an Apache2 License Software.Any contributions to Zeppelin (Source 
code, Documents, Image, Website) means you agree with license all your 
contributions as Apache2 Licen
 se.Getting the source codeFirst of all, you need Zeppelin source code. The 
official location of Zeppelin is 
http://git.apache.org/zeppelin.git.Documentation website is hosted in 
'master' branch under /docs/ dir.git accessFirst of all, you 
need the website source code. The official location of mirror for Zeppelin is 
http://git.apache.org/zeppelin.git.Get the source code on your development 
machine using git.git clone git://git.apache.org/zeppelin.gitcd docsApache 
Zeppelin follows Fork & Pull as a source control workflow.If you want 
to not only build Zeppelin but also make any changes, then you need to fork 
Zeppelin github mirror repository and make a pull request.BuildYou'll 
need to install some prerequisites to build the code. Please check Build 
documentation section in docs/README.md.Run website in development modeWhile 
you're modifying website, you might want to see preview of it. Please 
check Run website section in docs/README.md.Then you&a
 mp;#39;ll be able to access it on http://localhost:4000 with your web 
browser.Making a Pull RequestWhen you are ready, just make a 
pull-request.Alternative wayYou can directly edit .md files in /docs/ directory 
at the web interface of github and make pull-request immediately.Stay 
involvedContributors should join the Zeppelin mailing 
lists....@zeppelin.apache.org is for people who want to contribute code to 
Zeppelin. subscribe, unsubscribe, archivesIf you have any issues, create a 
ticket in JIRA.",
-      "url": " /development/howtocontributewebsite.html",
-      "group": "development",
+      "url": " /development/contribution/how_to_contribute_website.html",
+      "group": "development/contribution",
       "excerpt": "How can you contribute to Apache Zeppelin project website? 
This document covers from building Zeppelin documentation site to making a pull 
request on Github."
     }
     ,
     
   
 
-    "/development/writingzeppelinapplication.html": {
-      "title": "Writing a new Application",
-      "content"  : "<!--Licensed under the Apache License, Version 2.0 (the 
"License");you may not use this file except in compliance with the 
License.You may obtain a copy of the License 
athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law 
or agreed to in writing, softwaredistributed under the License is distributed 
on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, 
either express or implied.See the License for the specific language governing 
permissions andlimitations under the License.-->Writing a new 
ApplicationWhat is Apache Zeppelin ApplicationApache Zeppelin Application is a 
package that runs on Interpreter process and displays it's output 
inside of the notebook. While application runs on Interpreter process, 
it's able to access resources provided by Interpreter through 
ResourcePool. Output is always rendered by AngularDisplaySystem. Therefore 
application provides all the possiblities of making 
 interactive graphical application that uses data and processing power of any 
Interpreter.Make your own ApplicationWriting Application means extending 
org.apache.zeppelin.helium.Application. You can use your favorite IDE and 
language while Java class files are packaged into jar. Application class looks 
like/** * Constructor. Invoked when application is loaded */public 
Application(ApplicationContext context);/** * Invoked when there're 
(possible) updates in required resource set. * i.e. invoked after application 
load and after paragraph finishes. */public abstract void run(ResourceSet 
args);/** * Invoked before application unload. * Application is automatically 
unloaded with paragraph/notebook removal */public abstract void unload();You 
can check example applications under ./zeppelin-examples directory.Development 
modeIn the development mode, you can run your Application in your IDE as a 
normal java application and see the result inside of Zeppelin 
notebook.org.apache.zeppelin
 .helium.ZeppelinApplicationDevServer can run Zeppelin Application in 
development mode.// entry point for development modepublic static void 
main(String[] args) throws Exception {  // add resources for development mode  
LocalResourcePool pool = new LocalResourcePool("dev");  
pool.put("date", new Date());  // run application in 
devlopment mode with given resource  // in this case, Clock.class.getName() 
will be the application class name    
org.apache.zeppelin.helium.ZeppelinApplicationDevServer devServer = new 
org.apache.zeppelin.helium.ZeppelinApplicationDevServer(    
Clock.class.getName(), pool.getAll());  // start development mode  
devServer.start();  devServer.join();}In the Zeppelin notebook, run %dev run 
will connect to application running in development mode.Package filePackage 
file is a json file that provides information about the application.Json file 
contains the following information{  "name" : 
"[organization].
 [name]",  "description" : 
"Description",  "artifact" : 
"groupId:artifactId:version",  "className" 
: "your.package.name.YourApplicationClass",  
"resources" : [    ["resource.name", 
":resource.class.name"],    
["alternative.resource.name", 
":alternative.class.name"]  ],  "icon" : 
"<i 
class='icon'></i>"}nameName is a 
string in [group].[name] format.[group] and [name] allow only 
[A-Za-z0-9_].Group is normally the name of an organization who creates this 
application.descriptionA short description about the 
applicationartifactLocation of the jar 
artifact."groupId:artifactId:version" will load artifact from 
maven repository.If jar exists in the local filesystem, absolute/relative can 
be use
 d.e.g.When artifact exists in Maven repositoryartifact: 
"org.apache.zeppelin:zeppelin-examples:0.6.0"When artifact 
exists in the local filesystemartifact: 
"zeppelin-example/target/zeppelin-example-0.6.0.jar"classNameEntry
 point. Class that extends org.apache.zeppelin.helium.ApplicationresourcesTwo 
dimensional array that defines required resources by name or by className. 
Helium Application launcher will compare resources in the ResourcePool with the 
information in this field and suggest application only when all required 
resources are available in the ResourcePool.Resouce name is a string which will 
be compared with the name of objects in the ResourcePool. className is a string 
with ":" prepended, which will be compared with className of 
the objects in the ResourcePool.Application may require two or more resources. 
Required resources can be listed inside of the json array. For example, if the 
application requires object &quot
 ;name1", "name2" and "className1" 
type of object to run, resources field can beresources: [  [ 
"name1", "name2", 
":className1", ...]]If Application can handle alternative 
combination of required resources, alternative set can be listed as 
below.resources: [  [ "name", 
":className"],  [ "altName", 
":altClassName1"],  ...]Easier way to understand this scheme 
isresources: [   [ 'resource' AND 'resource' 
AND ... ] OR   [ 'resource' AND 'resource' AND 
... ] OR   ...]iconIcon to be used on the application button. String in this 
field will be rendered as a HTML tag.e.g.icon: "<i 
class='fa fa-clock-o'></i>"",
-      "url": " /development/writingzeppelinapplication.html",
-      "group": "development",
-      "excerpt": "Apache Zeppelin Application is a package that runs on 
Interpreter process and displays it's output inside of the notebook. Make your 
own Application in Apache Zeppelin is quite easy."
-    }
-    ,
-    
-  
-
-    "/development/writingzeppelininterpreter.html": {
-      "title": "Writing a New Interpreter",
-      "content"  : "<!--Licensed under the Apache License, Version 2.0 (the 
"License");you may not use this file except in compliance with the 
License.You may obtain a copy of the License 
athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law 
or agreed to in writing, softwaredistributed under the License is distributed 
on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, 
either express or implied.See the License for the specific language governing 
permissions andlimitations under the License.-->Writing a New 
InterpreterWhat is Apache Zeppelin InterpreterApache Zeppelin Interpreter is a 
language backend. For example to use scala code in Zeppelin, you need a scala 
interpreter.Every Interpreters belongs to an InterpreterGroup.Interpreters in 
the same InterpreterGroup can reference each other. For example, 
SparkSqlInterpreter can reference SparkInterpreter to get SparkContext from it 
while they're in the same group.In
 terpreterSetting is configuration of a given InterpreterGroup and a unit of 
start/stop interpreter.All Interpreters in the same InterpreterSetting are 
launched in a single, separate JVM process. The Interpreter communicates with 
Zeppelin engine via Thrift.In 'Separate Interpreter(scoped / isolated) 
for each note' mode which you can see at the Interpreter Setting menu 
when you create a new interpreter, new interpreter instance will be created per 
note. But it still runs on the same JVM while they're in the same 
InterpreterSettings.Make your own InterpreterCreating a new interpreter is 
quite simple. Just extend org.apache.zeppelin.interpreter abstract class and 
implement some methods.You can include 
org.apache.zeppelin:zeppelin-interpreter:[VERSION] artifact in your build 
system. And you should put your jars under your interpreter directory with a 
specific directory name. Zeppelin server reads interpreter directories 
recursively and initializes interpreters inc
 luding your own interpreter.There are three locations where you can store your 
interpreter group, name and other information. Zeppelin server tries to find 
the location below. Next, Zeppelin tries to find interpreter-setting.json in 
your interpreter 
jar.{ZEPPELIN_INTERPRETER_DIR}/{YOUR_OWN_INTERPRETER_DIR}/interpreter-setting.jsonHere
 is an example of interpreter-setting.json on your own interpreter.[  {    
"group": "your-group",    
"name": "your-name",    
"className": "your.own.interpreter.class",  
  "properties": {      "properties1": {     
   "envName": null,        "propertyName": 
"property.1.name",        "defaultValue": 
"propertyDefaultValue",        
"description": "Property description"      
},      "p
 roperties2": {        "envName": PROPERTIES_2,      
  "propertyName": null,        
"defaultValue": "property2DefaultValue",    
    "description": "Property 2 description" 
     }, ...    },    "editor": {      
"language": 
"your-syntax-highlight-language",      
"editOnDblClick": false    }  },  {    ...  }]Finally, 
Zeppelin uses static initialization with the following:static {  
Interpreter.register("MyInterpreterName", 
MyClassName.class.getName());}Static initialization is deprecated and will be 
supported until 0.6.0.The name will appear later in the interpreter name option 
box during the interpreter configuration process.The name of the interpreter is 
what you later write to identify a paragraph which should be interpreted using 
this interpreter.%MyInterpreterNamesome interpreter
  specific code...Editor setting for InterpreterYou can add editor object to 
interpreter-setting.json file to specify paragraph editor settings.LanguageIf 
the interpreter uses a specific programming language (like Scala, Python, SQL), 
it is generally recommended to add a syntax highlighting supported for that to 
the note paragraph editor.To check out the list of languages supported, see the 
mode-*.js files under zeppelin-web/bower_components/ace-builds/src-noconflict 
or from github.com/ajaxorg/ace-builds.If you want to add a new set of syntax 
highlighting,  Add the mode-*.js file to zeppelin-web/bower.json (when built, 
zeppelin-web/src/index.html will be changed automatically).Add language field 
to editor object. Note that if you don't specify language field, your 
interpreter will use plain text mode for syntax highlighting. Let's say 
you want to set your language to java, then add:"editor": {  
"language": "java"}E
 dit on double clickIf your interpreter uses mark-up language such as markdown 
or HTML, set editOnDblClick to true so that text editor opens on pargraph 
double click and closes on paragraph run. Otherwise set it to 
false."editor": {  "editOnDblClick": 
false}Install your interpreter binaryOnce you have built your interpreter, you 
can place it under the interpreter directory with all its 
dependencies.[ZEPPELIN_HOME]/interpreter/[INTERPRETER_NAME]/Configure your 
interpreterTo configure your interpreter you need to follow these steps:Add 
your interpreter class name to the zeppelin.interpreters property in 
conf/zeppelin-site.xml.Property value is comma separated 
[INTERPRETER_CLASS_NAME].For 
example,<property><name>zeppelin.interpreters</name><value>org.apache.zeppelin.spark.SparkInterpreter,org.apache.zeppelin.spark.PySparkInterpreter,org.apache.zeppelin.spark.SparkSqlInterpreter,org.apache.zeppeli
 
n.spark.DepInterpreter,org.apache.zeppelin.markdown.Markdown,org.apache.zeppelin.shell.ShellInterpreter,org.apache.zeppelin.hive.HiveInterpreter,com.me.MyNewInterpreter</value></property>Add
 your interpreter to the default configuration which is used when there is no 
zeppelin-site.xml.Start Zeppelin by running ./bin/zeppelin-daemon.sh start.In 
the interpreter page, click the +Create button and configure your interpreter 
properties.Now you are done and ready to use your interpreter.Note : 
Interpreters released with zeppelin have a default configuration which is used 
when there is no conf/zeppelin-site.xml.Use your interpreter0.5.0Inside of a 
note, %[INTERPRETER_NAME] directive will call your interpreter.Note that the 
first interpreter configuration in zeppelin.interpreters will be the default 
one.For example,%myintpval a = "My 
interpreter"println(a)0.6.0 and laterInside of a note, 
%[INTERPRETER_GROUP].[INTERPRETER_NAME] directive will cal
 l your interpreter.You can omit either [INTERPRETER_GROUP] or 
[INTERPRETER_NAME]. If you omit [INTERPRETER_NAME], then first available 
interpreter will be selected in the [INTERPRETER_GROUP].Likewise, if you skip 
[INTERPRETER_GROUP], then [INTERPRETER_NAME] will be chosen from default 
interpreter group.For example, if you have two interpreter myintp1 and myintp2 
in group mygrp, you can call myintp1 like%mygrp.myintp1codes for myintp1and you 
can call myintp2 like%mygrp.myintp2codes for myintp2If you omit your 
interpreter name, it'll select first available interpreter in the group 
( myintp1 ).%mygrpcodes for myintp1You can only omit your interpreter group 
when your interpreter group is selected as a default group.%myintp2codes for 
myintp2ExamplesCheckout some interpreters released with Zeppelin by 
default.sparkmarkdownshelljdbcContributing a new Interpreter to Zeppelin 
releasesWe welcome contribution to a new interpreter. Please follow these few 
steps:First, check out the gene
 ral contribution guide here.Follow the steps in Make your own Interpreter 
section and Editor setting for Interpreter above.Add your interpreter as in the 
Configure your interpreter section above; also add it to the example template 
zeppelin-site.xml.template.Add tests! They are run by Travis for all changes 
and it is important that they are self-contained.Include your interpreter as a 
module in pom.xml.Add documentation on how to use your interpreter under 
docs/interpreter/. Follow the Markdown style as this example. Make sure you 
list config settings and provide working examples on using your interpreter in 
code boxes in Markdown. Link to images as appropriate (images should go to 
docs/assets/themes/zeppelin/img/docs-img/). And add a link to your 
documentation in the navigation menu 
(docs/_includes/themes/zeppelin/_navigation.html).Most importantly, ensure 
licenses of the transitive closure of all dependencies are list in license 
file.Commit your changes and open a Pull Request on 
 the project Mirror on GitHub; check to make sure Travis CI build is passing.",
-      "url": " /development/writingzeppelininterpreter.html",
-      "group": "development",
-      "excerpt": "Apache Zeppelin Interpreter is a language backend. Every 
Interpreters belongs to an InterpreterGroup. Interpreters in the same 
InterpreterGroup can reference each other."
-    }
-    ,
-    
-  
-
-    "/development/writingzeppelinspell.html": {
-      "title": "Writing a new Spell",
-      "content"  : "<!--Licensed under the Apache License, Version 2.0 (the 
"License");you may not use this file except in compliance with the 
License.You may obtain a copy of the License 
athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law 
or agreed to in writing, softwaredistributed under the License is distributed 
on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, 
either express or implied.See the License for the specific language governing 
permissions andlimitations under the License.-->Writing a new SpellWhat is 
Apache Zeppelin SpellSpell is a kind of interpreter that runs on browser not on 
backend. So, technically it's the frontend interpreter.It can provide 
many benefits.Spell is pluggable frontend interpreter. So it can be installed 
and removed easily using helium registry.Every spell is written in javascript. 
It means you can use existing javascript libraries whatever you want.Spell runs 
on browser li
 ke display system (%html, %table). In other words, every spell can be used as 
display system as well.How it worksHelium Spell works like Helium 
Visualization.Every helium packages are loaded from central (online) registry 
or local registryYou can see loaded packages in /helium page.When you enable a 
spell, it's built from server and sent to clientFinally it will be 
loaded into browser.How to use spell1. EnablingFind a spell what you want to 
use in /helium package and click Enable button.2. UsingSpell works like an 
interpreter. Use the MAGIC value to execute spell in a note. (you might need to 
refresh after enabling)For example, Use %echo for the Echo Spell.Write a new 
SpellMaking a new spell is similar to Helium 
Visualization#write-new-visualization.Add framework dependency called 
zeppelin-spell into package.jsonWrite code using frameworkPublish your spell to 
npm1. Create a npm packageCreate a package.json in new directory for spell.You 
have to add a framework called zeppeli
 n-spell as a dependency to create spell (zeppelin-spell)Also, you can add any 
dependencies you want to utilise.Here's an example{  
"name": "zeppelin-echo-spell",  
"description": "Zeppelin Echo Spell 
(example)",  "version": "1.0.0",  
"main": "index",  
"author": "",  "license": 
"Apache-2.0",  "dependencies": {    
"zeppelin-spell": "*"  },  
"helium": {    "icon" : "<i 
class='fa fa-repeat'></i>",    
"spell": {      "magic": 
"%echo",      "usage": "%echo 
<TEXT>"    }  }}2. Write spell using frameworkHere are 
some exa
 mples you can referEcho SpellMarkdown Spell: Using libraryFlowchart Spell: 
Using DOMGoogle Translation API Spell: Using API (returning promise)Now, you 
need to write code to create spell which processing text.import {    SpellBase, 
   SpellResult,    DefaultDisplayType,} from 
'zeppelin-spell';export default class EchoSpell extends 
SpellBase {    constructor() {        /** pass magic to super class's 
constructor parameter */        super("%echo");    }    
interpret(paragraphText) {        const processed = paragraphText + 
'!';        /**         * should return `SpellResult` which 
including `data` and `type`         * default type is `TEXT` if you 
don't specify.           */        return new SpellResult(processed);   
 }}Here is another example. Let's say we want to create markdown spell. 
First of all, we should add a dependency for markdown in package.json// 
package.json "dependencies": {    
 "markdown": "0.5.0",    
"zeppelin-spell": "*"  },And here is spell 
code.import {    SpellBase,    SpellResult,    DefaultDisplayType,} from 
'zeppelin-spell';import md from 
'markdown';const markdown = md.markdown;export default class 
MarkdownSpell extends SpellBase {    constructor() {        
super("%markdown");    }    interpret(paragraphText) {        
const parsed = markdown.toHTML(paragraphText);        /**         * specify 
`DefaultDisplayType.HTML` since `parsed` will contain DOM         * otherwise 
it will be rendered as `DefaultDisplayType.TEXT` (default)         */        
return new SpellResult(parsed, DefaultDisplayType.HTML);    }}You might want to 
manipulate DOM directly (e.g google d3.js), then refer Flowchart SpellYou might 
want to return promise not string (e.g API call), then refer Google Translation 
API Spell3. Create Helium package file for local 
 deploymentYou don't want to publish your package every time you make a 
change in your spell. Zeppelin provides local deploy.The only thing you need to 
do is creating a Helium Package file (JSON) for local deploy.It's 
automatically created when you publish to npm repository but in local case, you 
should make it by yourself.{  "type" : 
"SPELL",  "name" : 
"zeppelin-echo-spell",  "version": 
"1.0.0",  "description" : "Return 
just what receive (example)",  "artifact" : 
"./zeppelin-examples/zeppelin-example-spell-echo",  
"license" : "Apache-2.0",  
"spell": {    "magic": 
"%echo",    "usage": "%echo 
<TEXT>"  }}Place this file in your local registry 
directory (de
 fault $ZEPPELIN_HOME/helium).type should be SPELLMake sure that artifact 
should be same as your spell directory.You can get information about other 
fields in Helium 
Visualization#3-create-helium-package-file-and-locally-deploy.4. Run in dev 
modecd zeppelin-webyarn run dev:heliumYou can browse localhost:9000. Every time 
refresh your browser, Zeppelin will rebuild your spell and reload changes.5. 
Publish your spell to the npm repositorySee Publishing npm packages",
-      "url": " /development/writingzeppelinspell.html",
-      "group": "development",
-      "excerpt": "Spell is a kind of interpreter that runs on browser not on 
backend. So, technically it's the frontend interpreter. "
-    }
-    ,
-    
-  
-
-    "/development/writingzeppelinvisualization.html": {
-      "title": "Writing a new Visualization",
-      "content"  : "<!--Licensed under the Apache License, Version 2.0 (the 
"License");you may not use this file except in compliance with the 
License.You may obtain a copy of the License 
athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law 
or agreed to in writing, softwaredistributed under the License is distributed 
on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, 
either express or implied.See the License for the specific language governing 
permissions andlimitations under the License.-->Writing a new 
VisualizationWhat is Apache Zeppelin VisualizationApache Zeppelin Visualization 
is a pluggable package that can be loaded/unloaded on runtime through Helium 
framework in Zeppelin. A Visualization is a javascript npm package and user can 
use them just like any other built-in visualization in notebook.How it works1. 
Load Helium package files from registryZeppelin needs to know what 
Visualization packages are available. 
 Zeppelin will read information of packages from both online and local 
registry.Registries are configurable through 
ZEPPELIN_HELIUM_LOCALREGISTRY_DEFAULT env variable or 
zeppelin.helium.localregistry.default property.2. Enable packagesOnce Zeppelin 
loads Helium package files from registries, available packages are displayed in 
Helium menu.Click 'enable' button.3. Create and load 
visualization bundle on the flyOnce a Visualization package is enabled, 
HeliumBundleFactory creates a js bundle. The js bundle is served by 
helium/bundle/load rest api endpoint.4. Run visualizationZeppelin shows 
additional button for loaded Visualizations.User can use just like any other 
built-in visualizations.Write new Visualization1. Create a npm packageCreate a 
package.json in your new Visualization directory. You can add any dependencies 
in package.json, but you must include two dependencies: zeppelin-vis and 
zeppelin-tabledata.Here's an example{  "name": &qu
 ot;zeppelin_horizontalbar",  "description" : 
"Horizontal Bar chart",  "version": 
"1.0.0",  "main": 
"horizontalbar",  "author": 
"",  "license": 
"Apache-2.0",  "dependencies": {    
"zeppelin-tabledata": "*",    
"zeppelin-vis": "*"  }}2. Create your own 
visualizationTo create your own visualization, you need to create a js file and 
import Visualization class from zeppelin-vis package and extend the class. 
zeppelin-tabledata package provides some useful transformations, like pivot, 
you can use in your visualization. (you can create your own transformation, 
too).Visualization class, there're several methods that you need to 
override and implement. Here's simple visualization that just prints 
Hello 
 world.import Visualization from 'zeppelin-vis'import 
PassthroughTransformation from 
'zeppelin-tabledata/passthrough'export default class helloworld 
extends Visualization {  constructor(targetEl, config) {    super(targetEl, 
config)    this.passthrough = new PassthroughTransformation(config);  }  
render(tableData) {    this.targetEl.html('Hello world!')  }  
getTransformation() {    return this.passthrough  }}To learn more about 
Visualization class, check visualization.js.You can check complete 
visualization package example here.Zeppelin's built-in visualization 
uses the same API, so you can check built-in visualizations as additional 
examples.3. Create Helium package file and locally deployHelium Package file is 
a json file that provides information about the application.Json file contains 
the following information{  "type" : 
"VISUALIZATION",  "name" : 
"zeppelin_hori
 zontalbar",  "description" : "Horizontal 
Bar chart (example)",  "license" : 
"Apache-2.0",  "artifact" : 
"./zeppelin-examples/zeppelin-example-horizontalbar",  
"icon" : "<i class='fa fa-bar-chart 
rotate90flipX'></i>"}Place this file in 
your local registry directory (default ./helium).typeWhen you're 
creating a visualization, 'type' should be 
'VISUALIZATION'.Check application type if you're 
interested in the other types of package.nameName of visualization. Should be 
unique. Allows [A-Za-z90-9_].descriptionA short description about 
visualization.artifactLocation of the visualization npm package. Support npm 
package with version or local filesystem path.e.g.When artifact exists in npm 
repository"artifact": "my-visualiz
 tion@1.0.0"When artifact exists in local file 
system"artifact": 
"/path/to/my/visualization"licenseLicense 
information.e.g."license": 
"Apache-2.0"iconIcon to be used in visualization select 
button. String in this field will be rendered as a HTML 
tag.e.g."icon": "<i class='fa 
fa-coffee'></i>"4. Run in dev modePlace 
your Helium package file in local registry (ZEPPELIN_HOME/helium).Run Zeppelin. 
And then run zeppelin-web in visualization dev mode.cd zeppelin-webyarn run 
dev:heliumYou can browse localhost:9000. Everytime refresh your browser, 
Zeppelin will rebuild your visualization and reload changes.5. Publish your 
visualizationOnce it's done, publish your visualization package using 
npm publish.That's it. With in an hour, your visualization will be 
available in Zeppelin's helium menu.",
-      "url": " /development/writingzeppelinvisualization.html",
-      "group": "development",
-      "excerpt": "Apache Zeppelin Visualization is a pluggable package that 
can be loaded/unloaded on runtime through Helium framework in Zeppelin. A 
Visualization is a javascript npm package and user can use them just like any 
other built-in visualization in a note."
-    }
-    ,
-    
-  
-
-    "/development/writingzeppelinvisualization_transformation.html": {
-      "title": "Transformations for Zeppelin Visualization",
-      "content"  : "<!--Licensed under the Apache License, Version 2.0 (the 
"License");you may not use this file except in compliance with the 
License.You may obtain a copy of the License 
athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law 
or agreed to in writing, softwaredistributed under the License is distributed 
on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, 
either express or implied.See the License for the specific language governing 
permissions andlimitations under the License.-->Transformations for Zeppelin 
VisualizationOverviewTransformations renders setting which allows users to set 
columns and transforms table rows according to the configured columns.Zeppelin 
provides 4 types of transformations.1. 
PassthroughTransformationPassthroughTransformation is the simple transformation 
which does not convert original tabledata at all.See passthrough.js2. 
ColumnselectorTransformationColumnselectorTransformation is
  uses when you need N axes but do not need aggregation. See 
columnselector.js3. PivotTransformationPivotTransformation provides group by 
and aggregation. Every chart using PivotTransformation has 3 axes. Keys, Groups 
and Values.See pivot.js4. AdvancedTransformationAdvancedTransformation has more 
detailed options while providing existing features of PivotTransformation and 
ColumnselectorTransformationmultiple sub chartsconfigurable chart axesparameter 
widgets: input, checkbox, option, textareaparsing parameters automatically 
based on their typesexpand / fold axis and parameter panelsmultiple 
transformation methods while supporting lazy converting re-initialize the whole 
configuration based on spec hash.SpecAdvancedTransformation requires spec which 
includes axis and parameter details for charts.Let's create 2 
sub-charts called line and no-group. Each sub chart can have different axis and 
parameter depending on their requirements.class AwesomeVisualization extends 
Visualizatio
 n {  constructor(targetEl, config) {    super(targetEl, config)    const spec 
= {      charts: {        'line': {          transform: { 
method: 'object', },          sharedAxis: false, /** set if you 
want to share axes between sub charts, default is `false` */          axis: {   
         'xAxis': { dimension: 'multiple', 
axisType: 'key', description: 'serial', },      
      'yAxis': { dimension: 'multiple', 
axisType: 'aggregator', description: 'serial', 
},            'category': { dimension: 
'multiple', axisType: 'group', description: 
'categorical', },          },          parameter: {            
'xAxisUnit': { valueType: 'string', 
defaultValue: '', description: 'unit of xAxis', 
},            &#3
 9;yAxisUnit': { valueType: 'string', defaultValue: 
'', description: 'unit of yAxis', },            
'lineWidth': { valueType: 'int', defaultValue: 
0, description: 'width of line', },          },        },       
 'no-group': {          transform: { method: 
'object', },          sharedAxis: false,          axis: {       
     'xAxis': { dimension: 'single', axisType: 
'key', },            'yAxis': { dimension: 
'multiple', axisType: 'value', },          },   
       parameter: {            'xAxisUnit': { valueType: 
'string', defaultValue: '', description: 
'unit of xAxis', },            'yAxisUnit': { 
valueType: 'string', defaultValue: '', 
description: 
 'unit of yAxis', },        },      },    }    
this.transformation = new AdvancedTransformation(config, spec)  }  ...  // 
`render` will be called whenever `axis` or `parameter` is changed   
render(data) {    const { chart, parameter, column, transformer, } = data    if 
(chart === 'line') {      const transformed = transformer()     
 // draw line chart     } else if (chart === 'no-group') {      
const transformed = transformer()      // draw no-group chart     }  }}Spec: 
axisField NameAvailable Values (type)DescriptiondimensionsingleAxis can 
contains only 1 columndimensionmultipleAxis can contains multiple 
columnsaxisTypekeyColumn(s) in this axis will be used as key like in 
PivotTransformation. These columns will be served in 
column.keyaxisTypeaggregatorColumn(s) in this axis will be used as value like 
in PivotTransformation. These columns will be served in 
column.aggregatoraxisTypegroupColumn(s) in this axis will be used as group like 
i
 n PivotTransformation. These columns will be served in 
column.groupaxisType(string)Any string value can be used here. These columns 
will be served in column.custommaxAxisCount (optional)(int)The max number of 
columns that this axis can contain. (unlimited if undefined)minAxisCount 
(optional)(int)The min number of columns that this axis should contain to draw 
chart. (1 in case of single dimension)description (optional)(string)Description 
for the axis.Here is an example.axis: {  'xAxis': { dimension: 
'multiple', axisType: 'key',  },  
'yAxis': { dimension: 'multiple', axisType: 
'aggregator'},  'category': { dimension: 
'multiple', axisType: 'group', maxAxisCount: 2, 
valueType: 'string', },},Spec: sharedAxisIf you set sharedAxis: 
false for sub charts, then their axes are persisted in global space (shared). 
It's useful for 
 when you creating multiple sub charts sharing their axes but have different 
parameters. For example, basic-column, stacked-column, percent-columnpie and 
donutHere is an example.    const spec = {      charts: {        
'column': {          transform: { method: 
'array', },          sharedAxis: true,          axis: { ... },  
        parameter: { ... },        },        'stacked': {       
   transform: { method: 'array', },          sharedAxis: true,  
        axis: { ... }          parameter: { ... },        },Spec: 
parameterField NameAvailable Values (type)DescriptionvalueTypestringParameter 
which has string valuevalueTypeintParameter which has int 
valuevalueTypefloatParameter which has float valuevalueTypebooleanParameter 
which has boolean value used with checkbox widget usuallyvalueTypeJSONParameter 
which has JSON value used with textarea widget usually. defaultValue should be 
"" (empty string). Thisdes
 cription(string)Description of this parameter. This value will be parsed as 
HTML for pretty outputwidgetinputUse input widget. This is the default widget 
(if widget is undefined)widgetcheckboxUse checkbox widget.widgettextareaUse 
textarea widget.widgetoptionUse select + option widget. This parameter should 
have optionValues field as well.optionValues(Array)Available option values used 
with the option widgetHere is an example.parameter: {  // string type, input 
widget  'xAxisUnit': { valueType: 'string', 
defaultValue: '', description: 'unit of xAxis', 
},  // boolean type, checkbox widget  'inverted': { widget: 
'checkbox', valueType: 'boolean', defaultValue: 
false, description: 'invert x and y axes', },  // string type, 
option widget with `optionValues`  'graphType': { widget: 
'option', valueType: 'string', defa
 ultValue: 'line', description: 'graph type', 
optionValues: [ 'line', 'smoothedLine', 
'step', ], },  // HTML in `description`  
'dateFormat': { valueType: 'string', 
defaultValue: '', description: 'format of date 
(<a 
href="https://docs.amcharts.com/3/javascriptcharts/AmGraph#dateFormat">doc</a>)
 (e.g YYYY-MM-DD)', },  // JSON type, textarea widget  
'yAxisGuides': { widget: 'textarea', valueType: 
'JSON', defaultValue: '', description: 
'guides of yAxis ', },Spec: transformField NameAvailable Values 
(type)Descriptionmethodobjectdesigned for rows requiring object 
manipulationmethodarraydesigned for rows requiring array 
manipulationmethodarray:2-keydesigned for xyz charts (e.g bubble 
chart)methoddrill-downdesigned for drill-d
 own chartsmethodrawwill return the original tableData.rowsWhatever you 
specified as transform.method, the transformer value will be always function 
for lazy computation. // advanced-transformation.util#getTransformerif 
(transformSpec.method === 'raw') {  transformer = () => 
{ return rows; }} else if (transformSpec.method === 'array') {  
transformer = () => {    ...    return { ... }  }}Here is actual 
usage.class AwesomeVisualization extends Visualization {  constructor(...) { 
/** setup your spec */ }  ...   // `render` will be called whenever `axis` or 
`parameter` are changed  render(data) {    const { chart, parameter, column, 
transformer, } = data    if (chart === 'line') {      const 
transformed = transformer()      // draw line chart     } else if (chart === 
'no-group') {      const transformed = transformer()      // 
draw no-group chart     }  }  ...}",
-      "url": " /development/writingzeppelinvisualization_transformation.html",
-      "group": "development",
-      "excerpt": "Description for Transformations"
-    }
-    ,
-    
-  
-
-    "/displaysystem/back-end-angular.html": {
-      "title": "Back-end Angular API in Apache Zeppelin",
-      "content"  : "<!--Licensed under the Apache License, Version 2.0 (the 
"License");you may not use this file except in compliance with the 
License.You may obtain a copy of the License 
athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law 
or agreed to in writing, softwaredistributed under the License is distributed 
on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, 
either express or implied.See the License for the specific language governing 
permissions andlimitations under the License.-->Back-end Angular API in 
Apache ZeppelinOverviewAngular display system treats output as a view template 
for AngularJS.It compiles templates and displays them inside of Apache 
Zeppelin. Zeppelin provides a gateway between your interpreter and your 
compiled AngularJS view templates.Therefore, you can not only update scope 
variables from your interpreter but also watch them in the interpreter, which 
is JVM process.Basic UsagePrint Angu
 larJS viewTo use angular display system, you should start with %angular.Since 
name is not defined, Hello will display Hello.Please Note: Display system is 
backend independent.Bind / Unbind VariablesThrough ZeppelinContext, you can 
bind / unbind variables to AngularJS view. Currently, it only works in Spark 
Interpreter ( scala ).// bind my 'object' as angular scope 
variable 'name' in current notebook.z.angularBind(String name, 
Object object)// bind my 'object' as angular scope variable 
'name' in all notebooks related to current 
interpreter.z.angularBindGlobal(String name, Object object)// unbind angular 
scope variable 'name' in current 
notebook.z.angularUnbind(String name)// unbind angular scope variable 
'name' in all notebooks related to current 
interpreter.z.angularUnbindGlobal(String name)Using the above example, 
let's bind world variable to name. Then you can see AngularJs view
  is immediately updated.Watch / Unwatch VariablesThrough ZeppelinContext, you 
can watch / unwatch variables in AngularJs view. Currently, it only works in 
Spark Interpreter ( scala ).// register for angular scope variable 
'name' (notebook)z.angularWatch(String name, (before, after) 
=> { ... })// unregister watcher for angular variable 
'name' (notebook)z.angularUnwatch(String name)// register for 
angular scope variable 'name' 
(global)z.angularWatchGlobal(String name, (before, after) => { ... })// 
unregister watcher for angular variable 'name' 
(global)z.angularUnwatchGlobal(String name)Let's make a button. When it 
is clicked, the value of run will be increased 1 by 
1.z.angularBind("run", 0) will initialize run to zero. And 
then, it will be also applied to run in z.angularWatch().When the button is 
clicked, you'll see both run and numWatched are incremented by 
1.Let's
  make it Simpler and more IntuitiveIn this section, we will introduce a 
simpler and more intuitive way of using Angular Display System in Zeppelin.Here 
are some usages.Import// In notebook scopeimport 
org.apache.zeppelin.display.angular.notebookscope._import AngularElem._// In 
paragraph scopeimport 
org.apache.zeppelin.display.angular.paragraphscope._import AngularElem._Display 
Element// automatically convert to string and print with %angular display 
system directive in front.<div></div>.displayEvent 
Handler// on click<div></div>.onClick(() => 
{   my callback routine}).display// on 
change<div></div>.onChange(() => {  my 
callback routine}).display// arbitrary 
event<div></div>.onEvent("ng-click",
 () => {  my callback routine}).displayBind Model// bind 
model<div></div>.model("myModel").display
 // bind model with initial 
value<div></div>.model("myModel", 
initialValue).displayInteract with Model// read 
modelAngularModel("myModel")()// update 
modelAngularModel("myModel", 
"newValue")Example: Basic UsageUsing the above basic usages, 
you can apply them like below examples.Display Elements<div 
style="color:blue">  <h4>Hello Angular 
Display System</h4></div>.displayOnClick 
Event<div class="btn btn-success">  Click 
me</div>.onClick{() =>  // callback for button 
click}.displayBind Model  
<div>{{{{myModel}}}}</div>.model("myModel",
 "Initial Value").displayInteract With Model// read the 
valueAngularModel("myModel")()// update the 
valueAngularModel("myModel", &amp
 ;quot;New value")Example: String ConverterUsing below example, you 
can convert the lowercase string to uppercase.// clear previously created 
angular object.AngularElem.disassociateval button = <div 
class="btn btn-success 
btn-sm">Convert</div>.onClick{() =>  val 
inputString = AngularModel("input")().toString  
AngularModel("title", 
inputString.toUpperCase)}<div>  { <h4> 
{{{{title}}}}</h4>.model("title", 
"Please type text to convert uppercase") }   Your text { 
<input 
type="text"></input>.model("input",
 "") }  {button}</div>.display",
-      "url": " /displaysystem/back-end-angular.html",
-      "group": "display",
-      "excerpt": "Apache Zeppelin provides a gateway between your interpreter 
and your compiled AngularJS view templates. You can not only update scope 
variables from your interpreter but also watch them in the interpreter, which 
is JVM process."
+    "/development/contribution/useful_developer_tools.html": {
+      "title": "Useful Developer Tools",
+      "content"  : "<!--Licensed under the Apache License, Version 2.0 (the 
"License");you may not use this file except in compliance with the 
License.You may obtain a copy of the License 
athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law 
or agreed to in writing, softwaredistributed under the License is distributed 
on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, 
either express or implied.See the License for the specific language governing 
permissions andlimitations under the License.-->Useful Developer 
ToolsDeveloping zeppelin-webCheck zeppelin-web: Local Development.ToolsSVM: 
Scala Version Managersvm would be useful when changing scala version 
frequently.JDK change script: OSXthis script would be helpful when changing JDK 
version frequently.function setjdk() {  if [ $# -ne 0 ]; then  # written based 
on OSX.   # use diffrent base path for other OS  removeFromPath 
'/System/Library/Frameworks/JavaVM.framewo
 rk/Home/bin'  if [ -n "${JAVA_HOME+x}" ]; then    
removeFromPath $JAVA_HOME  fi  export JAVA_HOME=`/usr/libexec/java_home -v $@`  
export PATH=$JAVA_HOME/bin:$PATH  fi}function removeFromPath() {  export 
PATH=$(echo $PATH | sed -E -e "s;:$1;;" -e 
"s;$1:?;;")}you can use this function like setjdk 1.8 / 
setjdk 1.7Building Submodules Selectively# build `zeppelin-web` onlymvn clean 
-pl 'zeppelin-web' package -DskipTests;# build 
`zeppelin-server` and its dependencies onlymvn clean package -pl 
'spark,spark-dependencies,python,markdown,zeppelin-server' --am 
-DskipTests# build spark related modules with default profiles: scala 2.10 mvn 
clean package -pl 'spark,spark-dependencies,zeppelin-server' 
--am -DskipTests# build spark related modules with profiles: scala 2.11, spark 
2.1 hadoop 2.7 ./dev/change_scala_version.sh 2.11mvn clean package -Pspark-2.1 
-Phadoop-2.7 -Pscala-2.11 -pl &am
 p;#39;spark,spark-dependencies,zeppelin-server' --am -DskipTests# 
build `zeppelin-server` and `markdown` with dependenciesmvn clean package -pl 
'markdown,zeppelin-server' --am -DskipTestsRunning Individual 
Tests# run the `HeliumBundleFactoryTest` test classmvn test -pl 
'zeppelin-server' --am -DfailIfNoTests=false 
-Dtest=HeliumBundleFactoryTestRunning Selenium TestsMake sure that Zeppelin 
instance is started to execute integration tests (= selenium tests).# run the 
`SparkParagraphIT` test classTEST_SELENIUM="true" mvn test 
-pl 'zeppelin-server' --am -DfailIfNoTests=false 
-Dtest=SparkParagraphIT# run the `testSqlSpark` test function only in the 
`SparkParagraphIT` class# but note that, some test might be dependent on the 
previous testsTEST_SELENIUM="true" mvn test -pl 
'zeppelin-server' --am -DfailIfNoTests=false 
-Dtest=SparkParagraphIT#testSqlSpark",
+      "url": " /development/contribution/useful_developer_tools.html",
+      "group": "development/contribution",
+      "excerpt": ""
     }
     ,
     
   
 
-    "/displaysystem/basicdisplaysystem.html": {
-      "title": "Basic Display System in Apache Zeppelin",
-      "content"  : "<!--Licensed under the Apache License, Version 2.0 (the 
"License");you may not use this file except in compliance with the 
License.You may obtain a copy of the License 
athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law 
or agreed to in writing, softwaredistributed under the License is distributed 
on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, 
either express or implied.See the License for the specific language governing 
permissions andlimitations under the License.-->Basic Display System in 
Apache ZeppelinTextBy default, Apache Zeppelin prints interpreter response as a 
plain text using text display system.You can explicitly say you're 
using text display system.HtmlWith %html directive, Zeppelin treats your output 
as HTMLMathematical expressionsHTML display system automatically formats 
mathematical expression using MathJax. You can use( INLINE EXPRESSION ) and $$ 
EXPRESSION $$ to format.
  For exampleTableIf you have data that row separated by n (newline) and column 
separated by t (tab) with first row as header row, for exampleYou can simply 
use %table display system to leverage Zeppelin's built in 
visualization.If table contents start with %html, it is interpreted as an 
HTML.Note : Display system is backend independent.NetworkWith the %network 
directive, Zeppelin treats your output as a graph. Zeppelin can leverage the 
Property Graph Model.What is the Labelled Property Graph Model?A Property Graph 
is a graph that has these elements:a set of verticeseach vertex has a unique 
identifier.each vertex has a set of outgoing edges.each vertex has a set of 
incoming edges.each vertex has a collection of properties defined by a map from 
key to valuea set of edgeseach edge has a unique identifier.each edge has an 
outgoing tail vertex.each edge has an incoming head vertex.each edge has a 
label that denotes the type of relationship between its two vertices.each edge 
has a
  collection of properties defined by a map from key to value.A Labelled 
Property Graph is a Property Graph where the nodes can be tagged with labels 
representing their different roles in the graph modelWhat are the APIs?The new 
NETWORK visualization is based on json with the following 
params:"nodes" (mandatory): list of nodes of the graph every 
node can have the following params:"id" (mandatory): the id 
of the node (must be unique);"label": the main Label of the 
node;"labels": the list of the labels of the 
node;"data": the data attached to the 
node;"edges": list of the edges of the 
graph;"id" (mandatory): the id of the edge (must be 
unique);"source" (mandatory): the id of source node of the 
edge;"target" (mandatory): the id of target node of the 
edge;"label": the main type of the edge;"data&qu
 ot;: the data attached to the edge;"labels": a map (K, V) 
where K is the node label and V is the color of the 
node;"directed": (true/false, default false) wich tells if is 
directed graph or not;"types": a distinct list of the edge 
types of the graphIf you click on a node or edge on the bottom of the paragraph 
you find a list of entity propertiesThis kind of graph can be easily flatten in 
order to support other visualization formats provided by Zeppelin.How to use 
it?An example of a simple 
graph%sparkprint(s"""%network {    
"nodes": [        {"id": 1},        
{"id": 2},        {"id": 3}    ],    
"edges": [        {"source": 1, 
"target": 2, "id" : 1},        
{"source": 2, "target": 3, 
"id" : 2},        {&qu
 ot;source": 1, "target": 2, "id" 
: 3},        {"source": 1, "target": 2, 
"id" : 4},        {"source": 2, 
"target": 1, "id" : 5},        
{"source": 2, "target": 1, 
"id" : 6}    ]}""")that will look 
like:A little more complex 
graph:%sparkprint(s"""%network {    
"nodes": [{"id": 1, 
"label": "User", "data": 
{"fullName":"Andrea 
Santurbano"}},{"id": 2, "label": 
"User", "data": 
{"fullName":"Lee Moon 
Soo"}},{"id": 3, "label": 
"Project", "data&
 amp;quot;: {"name":"Zeppelin"}}],    
"edges": [{"source": 2, 
"target": 1, "id" : 1, 
"label": 
"HELPS"},{"source": 2, 
"target": 3, "id" : 2, 
"label": 
"CREATE"},{"source": 1, 
"target": 3, "id" : 3, 
"label": "CONTRIBUTE_TO", 
"data": {"oldPR": 
"https://github.com/apache/zeppelin/pull/1582"}}],    
"labels": {"User": 
"#8BC34A", "Project": 
"#3071A9"},    "directed": true,    
"types": ["HELPS", 
"CREATE", 
"CONTRIBUTE_TO"]}""&am
 p;quot;)that will look like:",
-      "url": " /displaysystem/basicdisplaysystem.html",
-      "group": "display",
-      "excerpt": "There are 3 basic display systems in Apache Zeppelin. By 
default, Zeppelin prints interpreter responce as a plain text using text 
display system. With %html directive, Zeppelin treats your output as HTML. You 
can also simply use %table display system..."
+    "/development/helium/overview.html": {
+      "title": "Helium",
+      "content"  : "<!--Licensed under the Apache License, Version 2.0 (the 
"License");you may not use this file except in compliance with the 
License.You may obtain a copy of the License 
athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law 
or agreed to in writing, softwaredistributed under the License is distributed 
on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, 
either express or implied.See the License for the specific language governing 
permissions andlimitations under the License.-->Helium OverviewWhat is 
Helium?Helium is a plugin system that can extend Zeppelin a lot. For example, 
you can write custom display system or install already published one in Heliun 
Online Registry. Currently, Helium supports 4 types of package.Helium 
Visualization: Adding a new chart typeHelium Spell: Adding new interpreter, 
display system running on browserHelium Application Helium Interpreter: Adding 
a new custom interpreter",
+      "url": " /development/helium/overview.html",
+      "group": "development/helium",
+      "excerpt": ""
     }
     ,
     
   
 
-    "/displaysystem/front-end-angular.html": {
-      "title": "Front-end Angular API in Apache Zeppelin",
-      "content"  : "<!--Licensed under the Apache License, Version 2.0 (the 
"License");you may not use this file except in compliance with the 
License.You may obtain a copy of the License 
athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law 
or agreed to in writing, softwaredistributed under the License is distributed 
on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, 
either express or implied.See the License for the specific language governing 
permissions andlimitations under the License.-->Front-end Angular API in 
Apache ZeppelinBasic UsageIn addition to the back-end API to handle Angular 
objects binding, Apache Zeppelin also exposes a simple AngularJS z object on 
the front-end side to expose the same capabilities.This z object is accessible 
in the Angular isolated scope for each paragraph.Bind / Unbind VariablesThrough 
the z, you can bind / unbind variables to AngularJS view.Bind a value to an 
angular object and a m
 andatory target paragraph:%angular<form 
class="form-inline">  <div 
class="form-group">    <label 
for="superheroId">Super Hero: </label>   
 <input type="text" 
class="form-control" id="superheroId" 
placeholder="Superhero name ..." 
ng-model="superhero"></input>  
</div>  <button type="submit" 
class="btn btn-primary" 
ng-click="z.angularBind('superhero',superhero,'20160222-232336_1472609686')">
 Bind</button></form>Unbind/remove a value from 
angular object and a mandatory target paragraph:%angular<form 
class="form-inline">  <button 
type="submit" class="btn btn-p
 rimary" 
ng-click="z.angularUnbind('superhero','20160222-232336_1472609686')">
 UnBind</button></form>The signature for the 
z.angularBind() / z.angularUnbind() functions are:// 
Bindz.angularBind(angularObjectName, angularObjectValue, paragraphId);// 
Unbindz.angularUnbind(angularObjectName, angularObjectValue, paragraphId);All 
the parameters are mandatory.Run ParagraphYou can also trigger paragraph 
execution by calling z.runParagraph() function passing the appropriate 
paragraphId: %angular<form class="form-inline"> 
 <div class="form-group">    <label 
for="paragraphId">Paragraph Id: </label> 
   <input type="text" 
class="form-control" id="paragraphId" 
placeholder="Paragraph Id ..." ng-model="paragraph
 "></input>  </div>  <button 
type="submit" class="btn btn-primary" 
ng-click="z.runParagraph(paragraph)"> Run 
Paragraph</button></form>Overriding dynamic form 
with Angular ObjectThe front-end Angular Interaction API has been designed to 
offer richer form capabilities and variable binding. With the existing Dynamic 
Form system you can already create input text, select and checkbox forms but 
the choice is rather limited and the look & feel cannot be changed.The 
idea is to create a custom form using plain HTML/AngularJS code and bind 
actions on this form to push/remove Angular variables to targeted paragraphs 
using this new API. Consequently if you use the Dynamic Form syntax in a 
paragraph and there is a bound Angular object having the same name as the 
${formName}, the Angular object will have higher priority and the Dynamic Form 
will not be
  displayed. Example: Feature matrix comparisonHow does the front-end AngularJS 
API compares to the back-end API ? Below is a comparison matrix for both APIs:  
                      Actions            Front-end API            Back-end API  
                              Initiate binding            z.angularbind(var, 
initialValue, paragraphId)            z.angularBind(var, initialValue)          
                  Update value            same to ordinary angularjs scope 
variable, or z.angularbind(var, newValue, paragraphId)            
z.angularBind(var, newValue)                            Watching value          
  same to ordinary angularjs scope variable            z.angularWatch(var, 
(oldVal, newVal) => ...)                            Destroy binding          
  z.angularUnbind(var, paragraphId)            z.angularUnbind(var)             
               Executing Paragraph            z.runParagraph(paragraphId)       
     z.run(paragraphId)                            Executing Para
 graph (Specific paragraphs in other notes) (                        
z.run(noteid, paragraphId)                            Executing note            
            z.runNote(noteId)                     Both APIs are pretty similar, 
except for value watching where it is done naturally by AngularJS internals on 
the front-end and by user custom watcher functions in the back-end.There is 
also a slight difference in term of scope. Front-end API limits the Angular 
object binding to a paragraph scope whereas back-end API allows you to bind an 
Angular object at the global or note scope. This restriction has been designed 
purposely to avoid Angular object leaks and scope pollution.",
-      "url": " /displaysystem/front-end-angular.html",
-      "group": "display",
-      "excerpt": "In addition to the back-end API to handle Angular objects 
binding, Apache Zeppelin exposes a simple AngularJS z object on the front-end 
side to expose the same capabilities."
-    }
-    ,
-    
-  
-  
-
-    "/install/build.html": {
-      "title": "Build from Source",
-      "content"  : "<!--Licensed under the Apache License, Version 2.0 (the 
"License");you may not use this file except in compliance with the 
License.You may obtain a copy of the License 
athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law 
or agreed to in writing, softwaredistributed under the License is distributed 
on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, 
either express or implied.See the License for the specific language governing 
permissions andlimitations under the License.-->Building from SourceIf you 
want to build from source, you must first install the following dependencies:   
   Name    Value        Git    (Any Version)        Maven    3.1.x or higher    
    JDK    1.7  If you haven't installed Git and Maven yet, check the 
Build requirements section and follow the step by step instructions from 
there.1. Clone the Apache Zeppelin repositorygit clone 
https://github.com/apache/zeppelin.git2. B
 uild sourceYou can build Zeppelin with following maven command:mvn clean 
package -DskipTests [Options]If you're unsure about the options, use 
the same commands that creates official binary package.# update all pom.xml to 
use scala 2.11./dev/change_scala_version.sh 2.11# build zeppelin with all 
interpreters and include latest version of Apache spark support for local 
mode.mvn clean package -DskipTests -Pspark-2.0 -Phadoop-2.4 -Pr -Pscala-2.113. 
DoneYou can directly start Zeppelin by running after successful 
build:./bin/zeppelin-daemon.sh startCheck build-profiles section for further 
build options.If you are behind proxy, follow instructions in Proxy setting 
section.If you're interested in contribution, please check Contributing 
to Apache Zeppelin (Code) and Contributing to Apache Zeppelin (Website).Build 
profilesSpark InterpreterTo build with a specific Spark version, Hadoop version 
or specific features, define one or more of the following profiles and 
options:-Pspark
 -[version]Set spark major versionAvailable profiles 
are-Pspark-2.1-Pspark-2.0-Pspark-1.6-Pspark-1.5-Pspark-1.4-Pcassandra-spark-1.5-Pcassandra-spark-1.4-Pcassandra-spark-1.3-Pcassandra-spark-1.2-Pcassandra-spark-1.1minor
 version can be adjusted by -Dspark.version=x.x.x-Phadoop-[version]set hadoop 
major versionAvailable profiles 
are-Phadoop-0.23-Phadoop-1-Phadoop-2.2-Phadoop-2.3-Phadoop-2.4-Phadoop-2.6-Phadoop-2.7minor
 version can be adjusted by -Dhadoop.version=x.x.x-Pscala-[version] 
(optional)set scala version (default 2.10)Available profiles 
are-Pscala-2.10-Pscala-2.11-Pr (optional)enable R support with SparkR 
integration.-Pvendor-repo (optional)enable 3rd party vendor repository 
(cloudera)-Pmapr[version] (optional)For the MapR Hadoop Distribution, these 
profiles will handle the Hadoop version. As MapR allows different versions of 
Spark to be installed, you should specify which version of Spark is installed 
on the cluster by adding a Spark profile (-Pspark-1.6, -Pspark-2.0, etc.) 
 as needed.The correct Maven artifacts can be found for every version of MapR 
at http://doc.mapr.comAvailable profiles 
are-Pmapr3-Pmapr40-Pmapr41-Pmapr50-Pmapr51-Pexamples (optional)Bulid examples 
under zeppelin-examples directoryBuild command examplesHere are some examples 
with several options:# build with spark-2.1, 
scala-2.11./dev/change_scala_version.sh 2.11mvn clean package -Pspark-2.1 
-Phadoop-2.4 -Pscala-2.11 -DskipTests# build with spark-2.0, 
scala-2.11./dev/change_scala_version.sh 2.11mvn clean package -Pspark-2.0 
-Phadoop-2.4 -Pscala-2.11 -DskipTests# build with spark-1.6, scala-2.10mvn 
clean package -Pspark-1.6 -Phadoop-2.4 -DskipTests# spark-cassandra 
integrationmvn clean package -Pcassandra-spark-1.5 -Dhadoop.version=2.6.0 
-Phadoop-2.6 -DskipTests -DskipTests# with CDHmvn clean package -Pspark-1.5 
-Dhadoop.version=2.6.0-cdh5.5.0 -Phadoop-2.6 -Pvendor-repo -DskipTests# with 
MapRmvn clean package -Pspark-1.5 -Pmapr50 -DskipTestsIgnite Interpretermvn 
clean package -Dignite.
 version=1.9.0 -DskipTestsScalding Interpretermvn clean package -Pscalding 
-DskipTestsBuild requirementsInstall requirementsIf you don't have 
requirements prepared, install it.(The installation method may vary according 
to your environment, example is for Ubuntu.)sudo apt-get updatesudo apt-get 
install gitsudo apt-get install openjdk-7-jdksudo apt-get install npmsudo 
apt-get install libfontconfigInstall mavenwget 
http://www.eu.apache.org/dist/maven/maven-3/3.3.9/binaries/apache-maven-3.3.9-bin.tar.gzsudo
 tar -zxf apache-maven-3.3.9-bin.tar.gz -C /usr/local/sudo ln -s 
/usr/local/apache-maven-3.3.9/bin/mvn /usr/local/bin/mvnNotes: - Ensure node is 
installed by running node --version - Ensure maven is running version 3.1.x or 
higher with mvn -version - Configure maven to use more memory than usual by 
export MAVEN_OPTS="-Xmx2g -XX:MaxPermSize=1024m"Proxy setting 
(optional)If you're behind the proxy, you'll need to configure 
maven and npm to pass 
 through it.First of all, configure maven in your 
~/.m2/settings.xml.<settings>  <proxies>    
<proxy>      <id>proxy-http</id>      
<active>true</active>      
<protocol>http</protocol>      
<host>localhost</host>      
<port>3128</port>      <!-- 
<username>usr</username>      
<password>pwd</password> -->      
<nonProxyHosts>localhost|127.0.0.1</nonProxyHosts>  
  </proxy>    <proxy>      
<id>proxy-https</id>      
<active>true</active>      
<protocol>https</protocol>      
<host>localhost</host>      
<port>3128</port>      <!-- <usern
 ame>usr</username>      
<password>pwd</password> -->      
<nonProxyHosts>localhost|127.0.0.1</nonProxyHosts>  
  </proxy>  
</proxies></settings>Then, next commands will 
configure npm.npm config set proxy http://localhost:3128npm config set 
https-proxy http://localhost:3128npm config set registry 
"http://registry.npmjs.org/"npm config set strict-ssl 
falseConfigure git as wellgit config --global http.proxy 
http://localhost:3128git config --global https.proxy http://localhost:3128git 
config --global url."http://".insteadOf git://To clean up, 
set active false in Maven settings.xml and run these commands.npm config rm 
proxynpm config rm https-proxygit config --global --unset http.proxygit config 
--global --unset https.proxygit config --global --unset 
url."http://".insteadOfNotes: - If you are behind NTLM proxy y
 ou can use Cntlm Authentication Proxy. - Replace localhost:3128 with the 
standard pattern http://user:pwd@host:port.PackageTo package the final 
distribution including the compressed archive, run:mvn clean package 
-Pbuild-distrTo build a distribution with specific profiles, run:mvn clean 
package -Pbuild-distr -Pspark-1.5 -Phadoop-2.4The profiles -Pspark-1.5 
-Phadoop-2.4 can be adjusted if you wish to build to a specific spark versions. 
 The archive is generated under zeppelin-distribution/target directoryRun 
end-to-end testsZeppelin comes with a set of end-to-end acceptance tests 
driving headless selenium browser# assumes zeppelin-server running on 
localhost:8080 (use -Durl=.. to override)mvn verify# or take care of 
starting/stoping zeppelin-server from packaged zeppelin-distribuion/targetmvn 
verify -P using-packaged-distr",
-      "url": " /install/build.html",
-      "group": "install",
-      "excerpt": "How to build Zeppelin from source"
-    }
-    ,
-    
-  
-
-    "/install/cdh.html": {
-      "title": "Apache Zeppelin on CDH",
-      "content"  : "<!--Licensed under the Apache License, Version 2.0 (the 
"License");you may not use this file except in compliance with the 
License.You may obtain a copy of the License 
athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law 
or agreed to in writing, softwaredistributed under the License is distributed 
on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, 
either express or implied.See the License for the specific language governing 
permissions andlimitations under the License.-->Apache Zeppelin on CDH1. 
Import Cloudera QuickStart Docker imageCloudera has officially provided CDH 
Docker Hub in their own container. Please check this guide page for more 
information.You can import the Docker image by pulling it from Cloudera Docker 
Hub.docker pull cloudera/quickstart:latest2. Run dockerdocker run -it  -p 80:80 
 -p 4040:4040  -p 8020:8020  -p 8022:8022  -p 8030:8030  -p 8032:8032  -p 
8033:8033  -p 8040:8040  -p 
 8042:8042  -p 8088:8088  -p 8480:8480  -p 8485:8485  -p 8888:8888  -p 
9083:9083  -p 10020:10020  -p 10033:10033  -p 18088:18088  -p 19888:19888  -p 
25000:25000  -p 25010:25010  -p 25020:25020  -p 50010:50010  -p 50020:50020  -p 
50070:50070  -p 50075:50075  -h quickstart.cloudera --privileged=true  
agitated_payne_backup /usr/bin/docker-quickstart;3. Verify running CDHTo verify 
the application is running well, check the web UI for HDFS on 
http://<hostname>:50070/ and YARN on 
http://<hostname>:8088/cluster.4. Configure Spark interpreter in 
ZeppelinSet following configurations to conf/zeppelin-env.sh.export 
MASTER=yarn-clientexport HADOOP_CONF_DIR=[your_hadoop_conf_path]export 
SPARK_HOME=[your_spark_home_path]HADOOP_CONF_DIR(Hadoop configuration path) is 
defined in /scripts/docker/spark-cluster-managers/cdh/hdfs_conf.Don't 
forget to set Spark master as yarn-client in Zeppelin Interpreters setting page 
like below.5. Run Zeppelin with Spark interpreterA
 fter running a single paragraph with Spark interpreter in Zeppelin,browse 
http://<hostname>:8088/cluster/apps to check Zeppelin application 
is running well or not.",
-      "url": " /install/cdh.html",
-      "group": "install",
-      "excerpt": "This document will guide you how you can build and configure 
the environment on CDH with Apache Zeppelin using docker scripts."
-    }
-    ,
-    
-  
-
-    "/install/configuration.html": {
-      "title": "Apache Zeppelin Configuration",

[... 804 lines stripped ...]
Modified: zeppelin/site/docs/0.8.0-SNAPSHOT/sitemap.txt
URL: 
http://svn.apache.org/viewvc/zeppelin/site/docs/0.8.0-SNAPSHOT/sitemap.txt?rev=1800233&r1=1800232&r2=1800233&view=diff
==============================================================================
--- zeppelin/site/docs/0.8.0-SNAPSHOT/sitemap.txt (original)
+++ zeppelin/site/docs/0.8.0-SNAPSHOT/sitemap.txt Thu Jun 29 06:33:24 2017
@@ -1,26 +1,16 @@
 
 http://zeppelin.apache.org/assets/themes/zeppelin/js/search.js
 http://zeppelin.apache.org/atom.xml
-http://zeppelin.apache.org/development/howtocontribute.html
-http://zeppelin.apache.org/development/howtocontributewebsite.html
-http://zeppelin.apache.org/development/writingzeppelinapplication.html
-http://zeppelin.apache.org/development/writingzeppelininterpreter.html
-http://zeppelin.apache.org/development/writingzeppelinspell.html
-http://zeppelin.apache.org/development/writingzeppelinvisualization.html
-http://zeppelin.apache.org/development/writingzeppelinvisualization_transformation.html
-http://zeppelin.apache.org/displaysystem/back-end-angular.html
-http://zeppelin.apache.org/displaysystem/basicdisplaysystem.html
-http://zeppelin.apache.org/displaysystem/front-end-angular.html
+http://zeppelin.apache.org/development/contribution/how_to_contribute_code.html
+http://zeppelin.apache.org/development/contribution/how_to_contribute_website.html
+http://zeppelin.apache.org/development/contribution/useful_developer_tools.html
+http://zeppelin.apache.org/development/helium/overview.html
+http://zeppelin.apache.org/development/helium/writing_application.html
+http://zeppelin.apache.org/development/helium/writing_spell.html
+http://zeppelin.apache.org/development/helium/writing_visualization_basic.html
+http://zeppelin.apache.org/development/helium/writing_visualization_transformation.html
+http://zeppelin.apache.org/development/writing_zeppelin_interpreter.html
 http://zeppelin.apache.org/index.html
-http://zeppelin.apache.org/install/build.html
-http://zeppelin.apache.org/install/cdh.html
-http://zeppelin.apache.org/install/configuration.html
-http://zeppelin.apache.org/install/docker.html
-http://zeppelin.apache.org/install/install.html
-http://zeppelin.apache.org/install/spark_cluster_mode.html
-http://zeppelin.apache.org/install/upgrade.html
-http://zeppelin.apache.org/install/virtual_machine.html
-http://zeppelin.apache.org/install/yarn_install.html
 http://zeppelin.apache.org/interpreter/alluxio.html
 http://zeppelin.apache.org/interpreter/beam.html
 http://zeppelin.apache.org/interpreter/bigquery.html
@@ -47,35 +37,54 @@ http://zeppelin.apache.org/interpreter/s
 http://zeppelin.apache.org/interpreter/scio.html
 http://zeppelin.apache.org/interpreter/shell.html
 http://zeppelin.apache.org/interpreter/spark.html
-http://zeppelin.apache.org/manual/dependencymanagement.html
-http://zeppelin.apache.org/manual/dynamicform.html
-http://zeppelin.apache.org/manual/dynamicinterpreterload.html
-http://zeppelin.apache.org/manual/interpreterexechooks.html
-http://zeppelin.apache.org/manual/interpreterinstallation.html
-http://zeppelin.apache.org/manual/interpreters.html
-http://zeppelin.apache.org/manual/notebookashomepage.html
-http://zeppelin.apache.org/manual/publish.html
-http://zeppelin.apache.org/manual/userimpersonation.html
 http://zeppelin.apache.org/pleasecontribute.html
-http://zeppelin.apache.org/quickstart/explorezeppelinui.html
-http://zeppelin.apache.org/quickstart/install_with_flink_and_spark_cluster.html
+http://zeppelin.apache.org/quickstart/explore_ui.html
+http://zeppelin.apache.org/quickstart/install.html
+http://zeppelin.apache.org/quickstart/python_with_zeppelin.html
+http://zeppelin.apache.org/quickstart/spark_with_zeppelin.html
+http://zeppelin.apache.org/quickstart/sql_with_zeppelin.html
 http://zeppelin.apache.org/quickstart/tutorial.html
-http://zeppelin.apache.org/rest-api/rest-configuration.html
-http://zeppelin.apache.org/rest-api/rest-credential.html
-http://zeppelin.apache.org/rest-api/rest-helium.html
-http://zeppelin.apache.org/rest-api/rest-interpreter.html
-http://zeppelin.apache.org/rest-api/rest-notebook.html
-http://zeppelin.apache.org/rest-api/rest-notebookRepo.html
-http://zeppelin.apache.org/rest-api/rest-zeppelin-server.html
 http://zeppelin.apache.org/rss.xml
 http://zeppelin.apache.org/screenshots.html
 http://zeppelin.apache.org/search.html
 http://zeppelin.apache.org/search_data.json
-http://zeppelin.apache.org/security/authentication.html
-http://zeppelin.apache.org/security/datasource_authorization.html
-http://zeppelin.apache.org/security/helium_authorization.html
-http://zeppelin.apache.org/security/notebook_authorization.html
-http://zeppelin.apache.org/security/shiroauthentication.html
+http://zeppelin.apache.org/setup/basics/how_to_build.html
+http://zeppelin.apache.org/setup/basics/multi_user_support.html
+http://zeppelin.apache.org/setup/deployment/cdh.html
+http://zeppelin.apache.org/setup/deployment/docker.html
+http://zeppelin.apache.org/setup/deployment/flink_and_spark_cluster.html
+http://zeppelin.apache.org/setup/deployment/spark_cluster_mode.html
+http://zeppelin.apache.org/setup/deployment/virtual_machine.html
+http://zeppelin.apache.org/setup/deployment/yarn_install.html
+http://zeppelin.apache.org/setup/operation/configuration.html
+http://zeppelin.apache.org/setup/operation/proxy_setting.html
+http://zeppelin.apache.org/setup/operation/trouble_shooting.html
+http://zeppelin.apache.org/setup/operation/upgrading.html
+http://zeppelin.apache.org/setup/security/authentication_nginx.html
+http://zeppelin.apache.org/setup/security/datasource_authorization.html
+http://zeppelin.apache.org/setup/security/notebook_authorization.html
+http://zeppelin.apache.org/setup/security/shiro_authentication.html
+http://zeppelin.apache.org/setup/storage/storage.html
 http://zeppelin.apache.org/sitemap.txt
-http://zeppelin.apache.org/storage/storage.html
+http://zeppelin.apache.org/usage/display_system/angular_backend.html
+http://zeppelin.apache.org/usage/display_system/angular_frontend.html
+http://zeppelin.apache.org/usage/display_system/basic.html
+http://zeppelin.apache.org/usage/dynamic_form/intro.html
+http://zeppelin.apache.org/usage/interpreter/dependency_management.html
+http://zeppelin.apache.org/usage/interpreter/dynamic_loading.html
+http://zeppelin.apache.org/usage/interpreter/execution_hooks.html
+http://zeppelin.apache.org/usage/interpreter/installation.html
+http://zeppelin.apache.org/usage/interpreter/interpreter_binding_mode.html
+http://zeppelin.apache.org/usage/interpreter/overview.html
+http://zeppelin.apache.org/usage/interpreter/user_impersonation.html
+http://zeppelin.apache.org/usage/other_features/customizing_homepage.html
+http://zeppelin.apache.org/usage/other_features/personalized_mode.html
+http://zeppelin.apache.org/usage/other_features/publishing_paragraphs.html
+http://zeppelin.apache.org/usage/rest_api/configuration.html
+http://zeppelin.apache.org/usage/rest_api/credential.html
+http://zeppelin.apache.org/usage/rest_api/helium.html
+http://zeppelin.apache.org/usage/rest_api/interpreter.html
+http://zeppelin.apache.org/usage/rest_api/notebook.html
+http://zeppelin.apache.org/usage/rest_api/notebook_repository.html
+http://zeppelin.apache.org/usage/rest_api/zeppelin_server.html
 


Reply via email to