svn commit: r1809223 [27/30] - in /zeppelin/site: ./ contribution/ contribution/zeppelinweb/ docs/0.7.3/ docs/0.7.3/assets/ docs/0.7.3/assets/themes/ docs/0.7.3/assets/themes/zeppelin/ docs/0.7.3/assets/themes/zeppelin/bootstrap/ docs/0.7.3/assets/them...

Thu, 21 Sep 2017 13:35:14 -0700 

Added: zeppelin/site/docs/0.7.3/search_data.json
URL: 
http://svn.apache.org/viewvc/zeppelin/site/docs/0.7.3/search_data.json?rev=1809223&view=auto
==============================================================================
--- zeppelin/site/docs/0.7.3/search_data.json (added)
+++ zeppelin/site/docs/0.7.3/search_data.json Thu Sep 21 20:33:57 2017
@@ -0,0 +1,749 @@
+{
+  
+  
+  
+
+    "/development/howtocontribute.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.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 <zeppeli
 n_home>/zeppelin-interpreter/src/main/thrift./genthrift.shWhere 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",
+      "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": {
+      "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",
+      "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(Experimental)",
+      "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 Application 
(Experimental)What 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 possibli
 ties 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 used.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 "name1", 
"name2" and "className1" type of object to 
run, r
 esources 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/writingzeppelinvisualization.html": {
+      "title": "Writing a new Visualization(Experimental)",
+      "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 Visualization 
(Experimental)What 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 searches Helium package file from local registry (by 
default helium/ directory) by default.Helium package file provides informations 
like name, artifact, and so on. It's similar to package.json in npm 
package.Here's an example helium/zeppelin-example-horizontalbar.json{  
"type" : "VISUALIZATION",  
"name" : "zeppelin_horizontalbar",  
"description" : "Horizontal Bar chart 
(example)",  "artifact" : 
"./zeppelin-examples/zeppelin-example-horizontalbar",  
"license" : "Apache-2.0",  
"icon" : "<i class='fa fa-bar-chart 
rotate90flipX'></i>"}Check Create helium 
package file section to learn about it.2. Enable packagesOnce Zeppelin loads 
Helium package files from local registry, available packages a
 re displayed in Helium menu.Click 'enable' button.3. Create 
and load visualization bundle on the flyOnce a Visualization package is 
enabled, HeliumVisualizationFactory creates a js bundle. The js bundle is 
served by helium/visualization/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. 
Normally, you can add any dependencies in package.json however Zeppelin 
Visualization package only allows two dependencies: zeppelin-vis and 
zeppelin-tabledata.Here's an example{  "name": 
"zeppelin_horizontalbar",  "description" : 
"Horizontal Bar chart",  "version": 
"1.0.0",  "main": 
"horizontalbar",  "author&quot
 ;: "",  "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, con
 fig)    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 fileHelium Package file is a json file that 
provides information about the application.Json file contains the following 
information{  "type" : "VISUALIZATION",  
"name" : "zeppelin_horizontalbar",  
"description" : "Horizontal Bar chart 
(example)",  "license" : 
"Apache-2.0",  "artifact" : 
"./zeppelin-examples/zeppelin-example-horizontalbar",  &a
 mp;quot;icon" : "<i class='fa fa-bar-chart 
rotate90flipX'></i>"}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 
repositoryartifact: "my-visualiztion@1.0.0"When artifact 
exists in local file systemartifact: 
"/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'>&a
 mp;lt;/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 visdevYou can browse 
localhost:9000. Everytime refresh your browser, Zeppelin will rebuild your 
visualization and reload changes.",
+      "url": " /development/writingzeppelinvisualization.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."
+    }
+    ,
+    
+  
+
+    "/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."
+    }
+    ,
+    
+  
+
+    "/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.",
+      "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..."
+    }
+    ,
+    
+  
+
+    "/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 -Pyarn -Ppyspark 
-Psparkr -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 pr
 ofiles 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-Pyarn (optional)enable YARN support for local 
modeYARN for local mode is not supported for Spark v1.5.0 or higher. Set 
SPARK_HOME instead.-Ppyspark (optional)enable PySpark support for local 
mode.-Pr (optional)enable R support with SparkR integration.-Psparkr 
(optional)another R support with SparkR integration as well as local mode 
support.-Pvendor-repo (optional)enable 3rd party vendor rep
 ository (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 -Pyarn -Ppyspark -Psparkr -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 -Pyarn -Ppyspark -Psparkr -Pscala-2.11 -DskipTests# 
build with spark-1.6, scala-2.10mvn clean package -Pspark-1.6 -P
 hadoop-2.4 -Pyarn -Ppyspark -Psparkr -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>      <!-- 
<username>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 h
 ttp://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 
you 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.4 -Pyarn -PpysparkThe profiles 
-Pspark-1.5 -Phadoop-2.4 -Pyarn -Ppyspark can be adjusted if you wish to build 
to a specific spark versions, or omit support such as yarn.  The archive is 
generated under zeppelin-distribution/target directoryRun end-to-end 
testsZeppelin com
 es 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",
+      "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 
ConfigurationZeppelin PropertiesThere are two locations you can configure 
Apache Zeppelin.Environment variables can be defined 
conf/zeppelin-env.sh(confzeppelin-env.cmd for Windows).Java properties can ba 
defined in conf/zeppelin-site.xml.If both are defined, then the environment 
variables will take priority.      zeppelin-env.sh    zeppelin-site.xml    
Default value    Description        ZEPPELIN_PORT    zeppelin.s
 erver.port    8080    Zeppelin server port        Note: Please make sure 
you're not using the same port with      Zeppelin web application 
development port (default: 9000).        ZEPPELIN_SSL_PORT    
zeppelin.server.ssl.port    8443    Zeppelin Server ssl port (used when ssl 
environment/property is set to true)        ZEPPELIN_MEM    N/A    -Xmx1024m 
-XX:MaxPermSize=512m    JVM mem options        ZEPPELIN_INTP_MEM    N/A    
ZEPPELIN_MEM    JVM mem options for interpreter process        
ZEPPELIN_JAVA_OPTS    N/A        JVM options        ZEPPELIN_ALLOWED_ORIGINS    
zeppelin.server.allowed.origins    *    Enables a way to specify a ',' 
separated list of allowed origins for REST and websockets.  e.g. 
http://localhost:8080           N/A    zeppelin.anonymous.allowed    true    
The anonymous user is allowed by default.        ZEPPELIN_SERVER_CONTEXT_PATH   
 zeppelin.server.context.path    /    Context path of the web application       
 ZEPPELIN_SSL    zeppelin.ssl    false  
           ZEPPELIN_SSL_CLIENT_AUTH    zeppelin.ssl.client.auth    false        
    ZEPPELIN_SSL_KEYSTORE_PATH    zeppelin.ssl.keystore.path    keystore        
    ZEPPELIN_SSL_KEYSTORE_TYPE    zeppelin.ssl.keystore.type    JKS            
ZEPPELIN_SSL_KEYSTORE_PASSWORD    zeppelin.ssl.keystore.password                
ZEPPELIN_SSL_KEY_MANAGER_PASSWORD    zeppelin.ssl.key.manager.password          
      ZEPPELIN_SSL_TRUSTSTORE_PATH    zeppelin.ssl.truststore.path              
  ZEPPELIN_SSL_TRUSTSTORE_TYPE    zeppelin.ssl.truststore.type                
ZEPPELIN_SSL_TRUSTSTORE_PASSWORD    zeppelin.ssl.truststore.password            
    ZEPPELIN_NOTEBOOK_HOMESCREEN    zeppelin.notebook.homescreen        Display 
note IDs on the Apache Zeppelin homescreen e.g. 2A94M5J1Z        
ZEPPELIN_NOTEBOOK_HOMESCREEN_HIDE    zeppelin.notebook.homescreen.hide    false 
   Hide the note ID set by ZEPPELIN_NOTEBOOK_HOMESCREEN on the Apache Zeppelin 
homescreen. For the further information, please read Cust
 omize your Zeppelin homepage.        ZEPPELIN_WAR_TEMPDIR    
zeppelin.war.tempdir    webapps    Location of the jetty temporary directory    
    ZEPPELIN_NOTEBOOK_DIR    zeppelin.notebook.dir    notebook    The root 
directory where notebook directories are saved        
ZEPPELIN_NOTEBOOK_S3_BUCKET    zeppelin.notebook.s3.bucket    zeppelin    S3 
Bucket where notebook files will be saved        ZEPPELIN_NOTEBOOK_S3_USER    
zeppelin.notebook.s3.user    user    User name of an S3 buckete.g. 
bucket/user/notebook/2A94M5J1Z/note.json        ZEPPELIN_NOTEBOOK_S3_ENDPOINT   
 zeppelin.notebook.s3.endpoint    s3.amazonaws.com    Endpoint for the bucket   
     ZEPPELIN_NOTEBOOK_S3_KMS_KEY_ID    zeppelin.notebook.s3.kmsKeyID        
AWS KMS Key ID to use for encrypting data in S3 (optional)        
ZEPPELIN_NOTEBOOK_S3_EMP    zeppelin.notebook.s3.encryptionMaterialsProvider    
    Class name of a custom S3 encryption materials provider implementation to 
use for encrypting data in S3 (optional)    
     ZEPPELIN_NOTEBOOK_AZURE_CONNECTION_STRING    
zeppelin.notebook.azure.connectionString        The Azure storage account 
connection stringe.g. 
DefaultEndpointsProtocol=https;AccountName=<accountName>;AccountKey=<accountKey>
        ZEPPELIN_NOTEBOOK_AZURE_SHARE    zeppelin.notebook.azure.share    
zeppelin    Azure Share where the notebook files will be saved        
ZEPPELIN_NOTEBOOK_AZURE_USER    zeppelin.notebook.azure.user    user    
Optional user name of an Azure file sharee.g. 
share/user/notebook/2A94M5J1Z/note.json        ZEPPELIN_NOTEBOOK_STORAGE    
zeppelin.notebook.storage    org.apache.zeppelin.notebook.repo.GitNotebookRepo  
  Comma separated list of notebook storage locations        
ZEPPELIN_NOTEBOOK_ONE_WAY_SYNC    zeppelin.notebook.one.way.sync    false    If 
there are multiple notebook storage locations, should we treat the first one as 
the only source of truth?        ZEPPELIN_NOTEBOOK_PUBLIC    
zeppelin.notebook.public    true    Make note
 book public (set only owners) by default when created/imported. If set to 
false will add user to readers and writers as well, making it private and 
invisible to other users unless permissions are granted.        
ZEPPELIN_INTERPRETERS    zeppelin.interpreters      
org.apache.zeppelin.spark.SparkInterpreter,org.apache.zeppelin.spark.PySparkInterpreter,org.apache.zeppelin.spark.SparkSqlInterpreter,org.apache.zeppelin.spark.DepInterpreter,org.apache.zeppelin.markdown.Markdown,org.apache.zeppelin.shell.ShellInterpreter,
    ...              Comma separated interpreter configurations [Class]       
NOTE: This property is deprecated since Zeppelin-0.6.0 and will not be 
supported from Zeppelin-0.7.0.            ZEPPELIN_INTERPRETER_DIR    
zeppelin.interpreter.dir    interpreter    Interpreter directory        
ZEPPELIN_INTERPRETER_DEP_MVNREPO    zeppelin.interpreter.dep.mvnRepo    
http://repo1.maven.org/maven2/    Remote principal repository for 
interpreter's additional dependency loading 
        ZEPPELIN_DEP_LOCALREPO    zeppelin.dep.localrepo    local-repo    Local 
repository for dependency loader.ex)visualiztion modules of npm.        
ZEPPELIN_HELIUM_NPM_REGISTRY    zeppelin.helium.npm.registry    
http://registry.npmjs.org/    Remote Npm registry for Helium dependency loader  
      ZEPPELIN_INTERPRETER_OUTPUT_LIMIT    zeppelin.interpreter.output.limit    
102400    Output message from interpreter exceeding the limit will be truncated 
       ZEPPELIN_WEBSOCKET_MAX_TEXT_MESSAGE_SIZE    
zeppelin.websocket.max.text.message.size    1024000    Size (in characters) of 
the maximum text message that can be received by websocket.        
ZEPPELIN_SERVER_DEFAULT_DIR_ALLOWED    zeppelin.server.default.dir.allowed    
false    Enable directory listings on server.  SSL ConfigurationEnabling SSL 
requires a few configuration changes. First, you need to create certificates 
and then update necessary configurations to enable server side SSL and/or 
client side certificate authentication.
 Creating and configuring the CertificatesInformation how about to generate 
certificates and a keystore can be found here.A condensed example can be found 
in the top answer to this StackOverflow post.The keystore holds the private key 
and certificate on the server end. The trustore holds the trusted client 
certificates. Be sure that the path and password for these two stores are 
correctly configured in the password fields below. They can be obfuscated using 
the Jetty password tool. After Maven pulls in all the dependency to build 
Zeppelin, one of the Jetty jars contain the Password tool. Invoke this command 
from the Zeppelin home build directory with the appropriate version, user, and 
password.java -cp 
./zeppelin-server/target/lib/jetty-all-server-<version>.jar 
org.eclipse.jetty.util.security.Password <user> 
<password>If you are using a self-signed, a certificate signed by 
an untrusted CA, or if client authentication is enabled, then the clie
 nt must have a browser create exceptions for both the normal HTTPS port and 
WebSocket port. This can by done by trying to establish an HTTPS connection to 
both ports in a browser (e.g. if the ports are 443 and 8443, then visit 
https://127.0.0.1:443 and https://127.0.0.1:8443). This step can be skipped if 
the server certificate is signed by a trusted CA and client auth is 
disabled.Configuring server side SSLThe following properties needs to be 
updated in the zeppelin-site.xml in order to enable server side 
SSL.<property>  
<name>zeppelin.server.ssl.port</name>  
<value>8443</value>  
<description>Server ssl port. (used when ssl property is set to 
true)</description></property><property>
  <name>zeppelin.ssl</name>  
<value>true</value>  
<description>Should SSL be used by the servers?</desc
 ription></property><property>  
<name>zeppelin.ssl.keystore.path</name>  
<value>keystore</value>  
<description>Path to keystore relative to Zeppelin configuration 
directory</description></property><property>
  <name>zeppelin.ssl.keystore.type</name>  
<value>JKS</value>  <description>The 
format of the given keystore (e.g. JKS or 
PKCS12)</description></property><property>
  <name>zeppelin.ssl.keystore.password</name>  
<value>change me</value>  
<description>Keystore password. Can be obfuscated by the Jetty 
Password 
tool</description></property><property>
  <name>zeppelin.ssl.key.manager.password</name&amp
 ;gt;  <value>change me</value>  
<description>Key Manager password. Defaults to keystore password. 
Can be obfuscated.</description></property>Enabling 
client side certificate authenticationThe following properties needs to be 
updated in the zeppelin-site.xml in order to enable client side certificate 
authentication.<property>  
<name>zeppelin.server.ssl.port</name>  
<value>8443</value>  
<description>Server ssl port. (used when ssl property is set to 
true)</description></property><property>
  <name>zeppelin.ssl.client.auth</name>  
<value>true</value>  
<description>Should client authentication be used for SSL 
connections?</description></property><property>
  <name>zeppelin
 .ssl.truststore.path</name>  
<value>truststore</value>  
<description>Path to truststore relative to Zeppelin 
configuration directory. Defaults to the keystore 
path</description></property><property>
  <name>zeppelin.ssl.truststore.type</name>  
<value>JKS</value>  <description>The 
format of the given truststore (e.g. JKS or PKCS12). Defaults to the same type 
as the keystore 
type</description></property><property>
  <name>zeppelin.ssl.truststore.password</name>  
<value>change me</value>  
<description>Truststore password. Can be obfuscated by the Jetty 
Password tool. Defaults to the keystore 
password</description></property>Obfuscating 
Passwords using the Jetty Password ToolSecurity be
 st practices advise to not use plain text passwords and Jetty provides a 
password tool to help obfuscating the passwords used to access the KeyStore and 
TrustStore.The Password tool documentation can be found here.After using the 
tool:java -cp 
$ZEPPELIN_HOME/zeppelin-server/target/lib/jetty-util-9.2.15.v20160210.jar       
   org.eclipse.jetty.util.security.Password           password2016-12-15 
10:46:47.931:INFO::main: Logging initialized 
@101mspasswordOBF:1v2j1uum1xtv1zej1zer1xtn1uvk1v1vMD5:5f4dcc3b5aa765d61d8327deb882cf99update
 your configuration with the obfuscated password :<property>  
<name>zeppelin.ssl.keystore.password</name>  
<value>OBF:1v2j1uum1xtv1zej1zer1xtn1uvk1v1v</value> 
 <description>Keystore password. Can be obfuscated by the Jetty 
Password tool</description></property>Note: After 
updating these configurations, Zeppelin server needs to be restarted.",
+      "url": " /install/configuration.html",
+      "group": "install",
+      "excerpt": "This page will guide you to configure Apache Zeppelin using 
either environment variables or Java properties. Also, you can configure SSL 
for Zeppelin."
+    }
+    ,
+    
+  
+
+    "/install/docker.html": {
+      "title": "Apache Zeppelin Releases Docker Images",
+      "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.-->Docker Image for Apache 
Zeppelin ReleasesOverviewThis document contains instructions about making 
docker containers for Zeppelin. It mainly provides guidance into how to create, 
publish and run docker images for zeppelin releases.Quick StartInstalling 
DockerYou need to install docker on your machine.Running docker imagedocker run 
-p 8080:8080 --rm --name zeppelin 
apache/zeppelin:<release-version> Zeppelin will run at 
 http://localhost:8080.If you want to specify logs and notebook dir, docker run 
-p 8080:8080 --rm -v $PWD/logs:/logs -v $PWD/notebook:/notebook -e 
ZEPPELIN_LOG_DIR='/logs' -e 
ZEPPELIN_NOTEBOOK_DIR='/notebook' --name zeppelin 
apache/zeppelin:<release-version> # e.g 
'0.7.2'Building dockerfile locallycd $ZEPPELIN_HOMEcd 
scripts/docker/zeppelin/bindocker build -t my-zeppelin:my-tag ./",
+      "url": " /install/docker.html",
+      "group": "install",
+      "excerpt": "This document contains instructions about making docker 
containers for Zeppelin. It mainly provides guidance into how to create, 
publish and run docker images for zeppelin releases."
+    }
+    ,
+    
+  
+
+    "/install/install.html": {
+      "title": "Quick Start",
+      "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.-->Quick StartWelcome to Apache 
Zeppelin! On this page are instructions to help you get 
started.InstallationApache Zeppelin officially supports and is tested on the 
following environments:      Name    Value        Oracle JDK    1.7  (set 
JAVA_HOME)        OS    Mac OSX  Ubuntu 14.X  CentOS 6.X  Windows 7 Pro SP1  
Downloading Binary PackageTwo binary packages are available on the Apache 
Zeppelin Download Page. Only difference between 
 these two binaries is interpreters are included in the package file.Package 
with all interpreters.Just unpack it in a directory of your choice and 
you're ready to go.Package with net-install interpreters.Unpack and 
follow install additional interpreters to install interpreters. If 
you're unsure, just run ./bin/install-interpreter.sh --all and install 
all interpreters.Starting Apache ZeppelinStarting Apache Zeppelin from the 
Command LineOn all unix like platforms:bin/zeppelin-daemon.sh startIf you are 
on Windows:binzeppelin.cmdAfter Zeppelin has started successfully, go to 
http://localhost:8080 with your web browser.Stopping 
Zeppelinbin/zeppelin-daemon.sh stopStart Apache Zeppelin with a service 
managerNote : The below description was written based on Ubuntu Linux.Apache 
Zeppelin can be auto-started as a service with an init script, using a service 
manager like upstart.This is an example upstart script saved as 
/etc/init/zeppelin.confThis allows the service to be mana
 ged with commands such assudo service zeppelin start  sudo service zeppelin 
stop  sudo service zeppelin restartOther service managers could use a similar 
approach with the upstart argument passed to the zeppelin-daemon.sh 
script.bin/zeppelin-daemon.sh upstartzeppelin.confdescription 
"zeppelin"start on (local-filesystems and net-device-up 
IFACE!=lo)stop on shutdown# Respawn the process on unexpected 
terminationrespawn# respawn the job up to 7 times within a 5 second period.# If 
the job exceeds these values, it will be stopped and marked as failed.respawn 
limit 7 5# zeppelin was installed in /usr/share/zeppelin in this examplechdir 
/usr/share/zeppelinexec bin/zeppelin-daemon.sh upstartNext 
StepsCongratulations, you have successfully installed Apache Zeppelin! Here are 
few steps you might find useful:New to Apache Zeppelin...For an in-depth 
overview, head to Explore Apache Zeppelin UI.And then, try run tutorial 
notebook in your Zeppelin.And see how to change configura
 tions like port number, etc.Zeppelin with Apache Spark ...To know more about 
deep integration with Apache Spark, check Spark Interpreter.Zeppelin with JDBC 
data sources ...Check JDBC Interpreter to know more about configure and uses 
multiple JDBC data sources.Zeppelin with Python ...Check Python interpreter to 
know more about Matplotlib, Pandas, Conda/Docker environment 
integration.Multi-user environment ...Turn on authentication.Manage your 
notebook permission.For more informations, go to More -> Security 
section.Other useful informations ...Learn how Display System works.Use Service 
Manager to start Zeppelin.If you're using previous version please see 
Upgrade Zeppelin version.Building Apache Zeppelin from SourceIf you want to 
build from source instead of using binary package, follow the instructions 
here.",
+      "url": " /install/install.html",
+      "group": "install",
+      "excerpt": "This page will help you get started and will guide you 
through installing Apache Zeppelin and running it in the command line."
+    }
+    ,
+    
+  
+
+    "/install/spark_cluster_mode.html": {
+      "title": "Apache Zeppelin on Spark cluster mode",
+      "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 Spark 
Cluster ModeOverviewApache Spark has supported three cluster manager 
types(Standalone, Apache Mesos and Hadoop YARN) so far.This document will guide 
you how you can build and configure the environment on 3 types of Spark cluster 
manager with Apache Zeppelin using Docker scripts.So install docker on the 
machine first.Spark standalone modeSpark standalone is a simple cluster manager 
included with Spark that m
 akes it easy to set up a cluster.You can simply set up Spark standalone 
environment with below steps.Note : Since Apache Zeppelin and Spark use same 
8080 port for their web UI, you might need to change zeppelin.server.port in 
conf/zeppelin-site.xml.1. Build Docker fileYou can find docker script files 
under scripts/docker/spark-cluster-managers.cd 
$ZEPPELIN_HOME/scripts/docker/spark-cluster-managers/spark_standalonedocker 
build -t "spark_standalone" .2. Run dockerdocker run -it -p 
8080:8080 -p 7077:7077 -p 8888:8888 -p 8081:8081 -h sparkmaster --name 
spark_standalone spark_standalone bash;Note that sparkmaster hostname used here 
to run docker container should be defined in your /etc/hosts.3. Configure Spark 
interpreter in ZeppelinSet Spark master as 
spark://<hostname>:7077 in Zeppelin Interpreters setting page.4. 
Run Zeppelin with Spark interpreterAfter running single paragraph with Spark 
interpreter in Zeppelin, browse https://<hostname>
 :8080 and check whether Spark cluster is running well or not.You can also 
simply verify that Spark is running well in Docker with below command.ps -ef | 
grep sparkSpark on YARN modeYou can simply set up Spark on YARN docker 
environment with below steps.Note : Since Apache Zeppelin and Spark use same 
8080 port for their web UI, you might need to change zeppelin.server.port in 
conf/zeppelin-site.xml.1. Build Docker fileYou can find docker script files 
under scripts/docker/spark-cluster-managers.cd 
$ZEPPELIN_HOME/scripts/docker/spark-cluster-managers/spark_yarn_clusterdocker 
build -t "spark_yarn" .2. Run dockerdocker run -it  -p 
5000:5000  -p 9000:9000  -p 9001:9001  -p 8088:8088  -p 8042:8042  -p 8030:8030 
 -p 8031:8031  -p 8032:8032  -p 8033:8033  -p 8080:8080  -p 7077:7077  -p 
8888:8888  -p 8081:8081  -p 50010:50010  -p 50075:50075  -p 50020:50020  -p 
50070:50070  --name spark_yarn  -h sparkmaster  spark_yarn bash;Note that 
sparkmaster hostname used here to run doc
 ker container should be defined in your /etc/hosts.3. Verify running Spark on 
YARN.You can simply verify the processes of Spark and YARN are running well in 
Docker with below command.ps -efYou can also check each application web UI for 
HDFS on http://<hostname>:50070/, YARN on 
http://<hostname>:8088/cluster and Spark on 
http://<hostname>:8080/.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/spark_yarn_cluster/hdfs_conf.Don't
 forget to set Spark master as yarn-client in Zeppelin Interpreters setting 
page like below.5. Run Zeppelin with Spark interpreterAfter running a single 
paragraph with Spark interpreter in Zeppelin, browse 
http://<hostname>:8088/cluster/apps and check
  Zeppelin application is running well or not.Spark on Mesos modeYou can simply 
set up Spark on Mesos docker environment with below steps.1. Build Docker 
filecd $ZEPPELIN_HOME/scripts/docker/spark-cluster-managers/spark_mesosdocker 
build -t "spark_mesos" .2. Run dockerdocker run --net=host 
-it -p 8080:8080 -p 7077:7077 -p 8888:8888 -p 8081:8081 -p 8082:8082 -p 
5050:5050 -p 5051:5051 -p 4040:4040 -h sparkmaster --name spark_mesos 
spark_mesos bash;Note that sparkmaster hostname used here to run docker 
container should be defined in your /etc/hosts.3. Verify running Spark on 
Mesos.You can simply verify the processes of Spark and Mesos are running well 
in Docker with below command.ps -efYou can also check each application web UI 
for Mesos on http://<hostname>:5050/cluster and Spark on 
http://<hostname>:8080/.4. Configure Spark interpreter in 
Zeppelinexport MASTER=mesos://127.0.1.1:5050export 
MESOS_NATIVE_JAVA_LIBRARY=[PATH OF libmesos.so]expo
 rt SPARK_HOME=[PATH OF SPARK HOME]Don't forget to set Spark master as 
mesos://127.0.1.1:5050 in Zeppelin Interpreters setting page like below.5. Run 
Zeppelin with Spark interpreterAfter running a single paragraph with Spark 
interpreter in Zeppelin, browse 
http://<hostname>:5050/#/frameworks and check Zeppelin 
application is running well or not.Troubleshooting for Spark on MesosIf you 
have problem with hostname, use --add-host option when executing dockerrun## 
use `--add-host=moby:127.0.0.1` option to resolve## since docker container 
couldn't resolve `moby`: java.net.UnknownHostException: moby: moby: 
Name or service not known        at 
java.net.InetAddress.getLocalHost(InetAddress.java:1496)        at 
org.apache.spark.util.Utils$.findLocalInetAddress(Utils.scala:789)        at 
org.apache.spark.util.Utils$.org$apache$spark$util$Utils$$localIpAddress$lzycompute(Utils.scala:782)
        at org.apache.spark.util.Utils$.org$apache$spark$util$Utils$$localIpAddr
 ess(Utils.scala:782)If you have problem with mesos master, try 
mesos://127.0.0.1 instead of mesos://127.0.1.1I0103 20:17:22.329269   340 
sched.cpp:330] New master detected at master@127.0.1.1:5050I0103 
20:17:22.330749   340 sched.cpp:341] No credentials provided. Attempting to 
register without authenticationW0103 20:17:22.333531   340 sched.cpp:736] 
Ignoring framework registered message because it was sentfrom 
'master@127.0.0.1:5050' instead of the leading master 
'master@127.0.1.1:5050'W0103 20:17:24.040252   339 
sched.cpp:736] Ignoring framework registered message because it was sentfrom 
'master@127.0.0.1:5050' instead of the leading master 
'master@127.0.1.1:5050'W0103 20:17:26.150250   339 
sched.cpp:736] Ignoring framework registered message because it was sentfrom 
'master@127.0.0.1:5050' instead of the leading master 
'master@127.0.1.1:5050'W0103 20:17:26.737604   339 
sched.cpp:736] Ign
 oring framework registered message because it was sentfrom 
'master@127.0.0.1:5050' instead of the leading master 
'master@127.0.1.1:5050'W0103 20:17:35.241714   336 
sched.cpp:736] Ignoring framework registered message because it was sentfrom 
'master@127.0.0.1:5050' instead of the leading master 
'master@127.0.1.1:5050'",
+      "url": " /install/spark_cluster_mode.html",
+      "group": "install",
+      "excerpt": "This document will guide you how you can build and configure 
the environment on 3 types of Spark cluster manager(Standalone, Hadoop Yarn, 
Apache Mesos) with Apache Zeppelin using docker scripts."
+    }
+    ,
+    
+  
+
+    "/install/upgrade.html": {
+      "title": "Manual Zeppelin version upgrade procedure",
+      "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.-->Manual upgrade procedure for 
ZeppelinBasically, newer version of Zeppelin works with previous version 
notebook directory and configurations.So, copying notebook and conf directory 
should be enough.InstructionsStop Zeppelinbin/zeppelin-daemon.sh stopCopy your 
notebook and conf directory into a backup directoryDownload newer version of 
Zeppelin and Install. See Install page.Copy backup notebook and conf directory 
into newer version o
 f Zeppelin notebook and conf directoryStart Zeppelinbin/zeppelin-daemon.sh 
startMigration GuideUpgrading from Zeppelin 0.6 to 0.7From 0.7, we 
don't use ZEPPELIN_JAVA_OPTS as default value of 
ZEPPELIN_INTP_JAVA_OPTS and also the same for ZEPPELIN_MEM/ZEPPELIN_INTP_MEM. 
If user want to configure the jvm opts of interpreter process, please set 
ZEPPELIN_INTP_JAVA_OPTS and ZEPPELIN_INTP_MEM explicitly. If you don't 
set ZEPPELIN_INTP_MEM, Zeppelin will set it to -Xms1024m -Xmx1024m 
-XX:MaxPermSize=512m by default.Mapping from %jdbc(prefix) to %prefix is no 
longer available. Instead, you can use %[interpreter alias] with multiple 
interpreter setttings on GUI.Usage of ZEPPELIN_PORT is not supported in ssl 
mode. Instead use ZEPPELIN_SSL_PORT to configure the ssl port. Value from 
ZEPPELIN_PORT is used only when ZEPPELIN_SSL is set to false.The support on 
Spark 1.1.x to 1.3.x is deprecated.From 0.7, we uses pegdown as the 
markdown.parser.type option for the %md interpreter. Ren
 dered markdown might be different from what you expectedFrom 0.7 note.json 
format has been changed to support multiple outputs in a paragraph. Zeppelin 
will automatically convert old format to new format. 0.6 or lower version can 
read new note.json format but output will not be displayed. For the detail, see 
ZEPPELIN-212 and pull request.From 0.7 note storage layer will utilize 
GitNotebookRepo by default instead of VFSNotebookRepo storage layer, which is 
an extension of latter one with versioning capabilities on top of it.",
+      "url": " /install/upgrade.html",
+      "group": "install",
+      "excerpt": "This document will guide you through a procedure of manual 
upgrade your Apache Zeppelin instance to a newer version. Apache Zeppelin keeps 
backward compatibility for the notebook file format."
+    }
+    ,
+    
+  
+
+    "/install/virtual_machine.html": {
+      "title": "Apache Zeppelin on Vagrant Virtual Machine",

[... 577 lines stripped ...]

Reply via email to