You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@zeppelin.apache.org by mo...@apache.org on 2017/05/15 15:03:56 UTC

svn commit: r1795220 [2/2] - in /zeppelin/site/docs/0.8.0-SNAPSHOT: ./ assets/themes/zeppelin/img/screenshots/ displaysystem/ install/ interpreter/ manual/ quickstart/ security/

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=1795220&r1=1795219&r2=1795220&view=diff
==============================================================================
--- zeppelin/site/docs/0.8.0-SNAPSHOT/search_data.json (original)
+++ zeppelin/site/docs/0.8.0-SNAPSHOT/search_data.json Mon May 15 15:03:55 2017
@@ -82,7 +82,7 @@
 
     "/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", &
 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",
+      "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."
@@ -149,7 +149,7 @@
 
     "/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.-->Apache Zeppelin Releases Docker ImagesOverviewThis 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.Creating and Publishing Zeppelin docker imageIn order to be able to create and/or publish an image, you need to set the DockerHub credent
 ials DOCKER_USERNAME, DOCKER_PASSWORD, DOCKER_EMAIL variables as environment variables.To create an image for some release use :create_release.sh <release-version> <git-tag>.To publish the created image use :publish_release.sh <release-version> <git-tag>Running a Zeppelin  docker imageTo start Zeppelin, you need to pull the zeppelin release image: ```docker pull ${DOCKER_USERNAME}/zeppelin-release:docker run --rm -it -p 7077:7077 -p 8080:8080 ${DOCKER_USERNAME}/zeppelin-release: -c bash``* Then a docker container will start with a Zeppelin release on path :/usr/local/zeppelin/`Run zeppelin inside docker:/usr/local/zeppelin/bin/zeppelin.shTo Run Zeppelin in daemon modeMounting logs and notebooks zeppelin to folders on your host machinedocker run -p 7077:7077 -p 8080:8080 --privileged=true -v $PWD/logs:/logs -v $PWD/notebook:/notebook -e ZEPPELIN_NOTEBOOK_DIR='/notebook' -e ZEPPELIN_LOG_DIR='/logs'
  -d ${DOCKER_USERNAME}/zeppelin-release:<release-version> /usr/local/zeppelin/bin/zeppelin.shZeppelin will run at http://localhost:8080.",
+      "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.1'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."
@@ -160,7 +160,7 @@
 
     "/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.",
+      "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 information ...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."
@@ -292,7 +292,7 @@
 
     "/interpreter/groovy.html": {
       "title": "Apache Groovy Interpreter for 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.-->Groovy Interpreter for Apache ZeppelinSamples%groovy//get a parameter defined as z.angularBind('ngSearchParam', value, 'paragraph_id')//g is a context object for groovy to avoid mix with z objectdef param = g.angular('ngSearchParam')//send request https://www.googleapis.com/customsearch/v1?q=ngSearchParam_valuedef r = HTTP.get(  //assume you defined the groovy interpreter property  //
    `search_baseurl`='https://www.googleapis.com/customsearch/v1'  //in groovy object o.getProperty('A') == o.'A' == o.A == o['A']  url : g.search_baseurl,  query: [ q: param ],  headers: [    'Accept':'application/json',    //'Authorization:' : g.getProperty('search_auth'),  ] )//check response codeif( r.response.code==200 ) {  g.html().with{     //g.html() renders %angular to output and returns groovy.xml.MarkupBuilder    h2("the response ${r.response.code}")    span( r.response.body )    h2("headers")    pre( r.response.headers.join('n') )  }} else {  //just to show that it's possible to use println with multiline groovy string to render output  println("""%angular    <script> alert ("code=${r.response.code} n msg=${r.response.message}") 
 </script>  """)}%groovy//renders a table with headers a, b, c  and two rowsg.table(  [    ['a','b','c'],    ['a1','b1','c1'],    ['a2','b2','c2'],  ])the g objectg.angular(String name)Returns angular object by name. Look up notebook scope first and then global scope.g.angularBind(String name, Object value)Assign a new value into angular object namejava.util.Properties g.getProperties()returns all properties defined for this interpreterString g.getProperty('PROPERTY_NAME') groovy g.PROPERTY_NAMEg.'PROPERTY_NAME'g['PROPERTY_NAME']g.getProperties().getProperty('PROPERTY_NAME')All above the accessor to named property defined in groovy interpreter.In this case with name PROPERTY_NAMEgroovy.xml.MarkupBuilder g.html()Starts or continues renderin
 g of %angular to output and returns groovy.xml.MarkupBuilderMarkupBuilder is usefull to generate html (xml)void g.table(obj)starts or continues rendering table rows.obj:  List(rows) of List(columns) where first line is a header ",
+      "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.-->Groovy Interpreter for Apache ZeppelinSamples%groovy//get a parameter defined as z.angularBind('ngSearchParam', value, 'paragraph_id')//g is a context object for groovy to avoid mix with z objectdef param = g.angular('ngSearchParam')//send request https://www.googleapis.com/customsearch/v1?q=ngSearchParam_valuedef r = HTTP.get(  //assume you defined the groovy interpreter property  //
    `search_baseurl`='https://www.googleapis.com/customsearch/v1'  //in groovy object o.getProperty('A') == o.'A' == o.A == o['A']  url : g.search_baseurl,  query: [ q: param ],  headers: [    'Accept':'application/json',    //'Authorization:' : g.getProperty('search_auth'),  ],  ssl : g.getProperty('search_ssl') // assume groovy interpreter property search_ssl = HTTP.getNaiveSSLContext())//check response codeif( r.response.code==200 ) {  g.html().with{     //g.html() renders %angular to output and returns groovy.xml.MarkupBuilder    h2("the response ${r.response.code}")    span( r.response.body )    h2("headers")    pre( r.response.headers.join('n') )  }} else {  //just to show that it's possible to use println with multiline groovy string to render output  println("&qu
 ot;"%angular    <script> alert ("code=${r.response.code} n msg=${r.response.message}") </script>  """)}%groovy//renders a table with headers a, b, c  and two rowsg.table(  [    ['a','b','c'],    ['a1','b1','c1'],    ['a2','b2','c2'],  ])the g objectg.angular(String name)Returns angular object by name. Look up notebook scope first and then global scope.g.angularBind(String name, Object value)Assign a new value into angular object namejava.util.Properties g.getProperties()returns all properties defined for this interpreterString g.getProperty('PROPERTY_NAME') groovy g.PROPERTY_NAMEg.'PROPERTY_NAME'g['PROPERTY_NAME']g.getProperties().getProperty('PROPERTY_NAME')All above the accessor to named property
  defined in groovy interpreter.In this case with name PROPERTY_NAMEgroovy.xml.MarkupBuilder g.html()Starts or continues rendering of %angular to output and returns groovy.xml.MarkupBuilderMarkupBuilder is usefull to generate html (xml)void g.table(obj)starts or continues rendering table rows.obj:  List(rows) of List(columns) where first line is a header g.input(name, value )Creates text input with value specified. The parameter value is optional.g.select(name, default, Map<Object, String> options)Creates select input with defined options. The parameter default is optional.g.select('sex', 'm', ['m':'man', 'w':'woman'])g.checkbox(name, Collection checked, Map<Object, String> options)Creates checkbox input.g.get(name, default)Returns interpreter-based variable. Visibility depends on interpreter scope. The parameter default is optional.g.put(name, value)Stores new 
 value into interpreter-based variable. Visibility depends on interpreter scope.",
       "url": " /interpreter/groovy.html",
       "group": "interpreter",
       "excerpt": "Apache Groovy is a powerful, optionally typed and dynamic language, with static-typing and static compilation capabilities, for the Java platform aimed at improving developer productivity thanks to a concise, familiar and easy to learn syntax."
@@ -347,7 +347,7 @@
 
     "/interpreter/jdbc.html": {
       "title": "Generic JDBC Interpreter for 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.-->Generic JDBC Interpreter for Apache ZeppelinOverviewJDBC interpreter lets you create a JDBC connection to any data sources seamlessly.Inserts, Updates, and Upserts are applied immediately after running each statement.By now, it has been tested with:                    Postgresql -      JDBC Driver              Mysql -      JDBC Driver              MariaDB -      JDBC Driver              Redshift -      JDBC Driver              Apac
 he Hive -       JDBC Driver              Apache Phoenix itself is a JDBC driver              Apache Drill -       JDBC Driver              Apache Tajo -       JDBC Driver      If you are using other databases not in the above list, please feel free to share your use case. It would be helpful to improve the functionality of JDBC interpreter.Create a new JDBC InterpreterFirst, click + Create button at the top-right corner in the interpreter setting page.Fill Interpreter name field with whatever you want to use as the alias(e.g. mysql, mysql2, hive, redshift, and etc..). Please note that this alias will be used as %interpreter_name to call the interpreter in the paragraph. Then select jdbc as an Interpreter group. The default driver of JDBC interpreter is set as PostgreSQL. It means Zeppelin includes PostgreSQL driver jar in itself.So you don't need to add any dependencies(e.g. the artifact name or path for PostgreSQL driver jar) for PostgreSQL connection.The JDBC interpreter p
 roperties are defined by default like below.      Name    Default Value    Description        common.max_count    1000    The maximun number of SQL result to display        default.driver    org.postgresql.Driver    JDBC Driver Name        default.password        The JDBC user password        default.url    jdbc:postgresql://localhost:5432/    The URL for JDBC        default.user    gpadmin    The JDBC user name        default.precode        Some SQL which executes while opening connection        default.completer.schemaFilters        Сomma separated schema (schema = catalog = database) filters to get metadata for completions. Supports '%' symbol is equivalent to any set of characters. (ex. prod_v_%,public%,info)  If you want to connect other databases such as Mysql, Redshift and Hive, you need to edit the property values.You can also use Credential for JDBC authentication.If default.user and default.password properties are deleted(using X button) for database connection 
 in the interpreter setting page,the JDBC interpreter will get the account information from Credential.The below example is for Mysql connection.The last step is Dependency Setting. Since Zeppelin only includes PostgreSQL driver jar by default, you need to add each driver's maven coordinates or JDBC driver's jar file path for the other databases.That's it. You can find more JDBC connection setting examples(Mysql, MariaDB, Redshift, Apache Hive, Apache Phoenix, and Apache Tajo) in this section.More propertiesThere are more JDBC interpreter properties you can specify like below.      Property Name    Description        common.max_result    Max number of SQL result to display to prevent the browser overload. This is  common properties for all connections        zeppelin.jdbc.auth.type    Types of authentications' methods supported are SIMPLE, and KERBEROS        zeppelin.jdbc.principal    The principal name to load from the keytab        zeppelin.jdbc.keytab.
 location    The path to the keytab file          zeppelin.jdbc.auth.kerberos.proxy.enable      When auth type is Kerberos, enable/disable Kerberos proxy with the login user to get the connection. Default value is true.        default.jceks.file    jceks store path (e.g: jceks://file/tmp/zeppelin.jceks)        default.jceks.credentialKey    jceks credential key  You can also add more properties by using this method.For example, if a connection needs a schema parameter, it would have to add the property as follows:      name    value        default.schema    schema_name  Binding JDBC interpter to notebookTo bind the interpreters created in the interpreter setting page, click the gear icon at the top-right corner.Select(blue) or deselect(white) the interpreter buttons depending on your use cases. If you need to use more than one interpreter in the notebook, activate several buttons.Don't forget to click Save button, or you will face Interpreter *** is not found error.H
 ow to useRun the paragraph with JDBC interpreterTo test whether your databases and Zeppelin are successfully connected or not, type %jdbc_interpreter_name(e.g. %mysql) at the top of the paragraph and run show databases.%jdbc_interpreter_nameshow databasesIf the paragraph is FINISHED without any errors, a new paragraph will be automatically added after the previous one with %jdbc_interpreter_name.So you don't need to type this prefix in every paragraphs' header.Apply Zeppelin Dynamic FormsYou can leverage Zeppelin Dynamic Form inside your queries. You can use both the text input and select form parametrization features.%jdbc_interpreter_nameSELECT name, country, performerFROM demo.performersWHERE name='{{performer=Sheryl Crow|Doof|Fanfarlo|Los Paranoia}}'Usage precodeYou can set precode for each data source. Code runs once while opening the connection.PropertiesAn example settings of interpreter for the two data sources, each of which has its precode p
 arameter.      Property Name    Value        default.driver    org.postgresql.Driver        default.password    1        default.url    jdbc:postgresql://localhost:5432/        default.user    postgres        default.precode    set search_path='test_path'        mysql.driver    com.mysql.jdbc.Driver        mysql.password    1        mysql.url    jdbc:mysql://localhost:3306/        mysql.user    root        mysql.precode    set @v=12  UsageTest of execution precode for each data source. %jdbcshow search_pathReturns value of search_path which is set in the default.precode.%jdbc(mysql)select @vReturns value of v which is set in the mysql.precode.ExamplesHere are some examples you can refer to. Including the below connectors, you can connect every databases as long as it can be configured with it's JDBC driver.PostgresProperties      Name    Value        default.driver    org.postgresql.Driver        default.url    jdbc:postgresql://localhost:5432/        default.user   
  mysql_user        default.password    mysql_password  Postgres JDBC Driver DocsDependencies      Artifact    Excludes        org.postgresql:postgresql:9.4.1211      Maven Repository: org.postgresql:postgresqlMysqlProperties      Name    Value        default.driver    com.mysql.jdbc.Driver        default.url    jdbc:mysql://localhost:3306/        default.user    mysql_user        default.password    mysql_password  Mysql JDBC Driver DocsDependencies      Artifact    Excludes        mysql:mysql-connector-java:5.1.38      Maven Repository: mysql:mysql-connector-javaMariaDBProperties      Name    Value        default.driver    org.mariadb.jdbc.Driver        default.url    jdbc:mariadb://localhost:3306        default.user    mariadb_user        default.password    mariadb_password  MariaDB JDBC Driver DocsDependencies      Artifact    Excludes        org.mariadb.jdbc:mariadb-java-client:1.5.4      Maven Repository: org.mariadb.jdbc:mariadb-java-clientRedshiftProperties      Name    Valu
 e        default.driver    com.amazon.redshift.jdbc42.Driver        default.url    jdbc:redshift://your-redshift-instance-address.redshift.amazonaws.com:5439/your-database        default.user    redshift_user        default.password    redshift_password  AWS Redshift JDBC Driver DocsDependencies      Artifact    Excludes        com.amazonaws:aws-java-sdk-redshift:1.11.51      Maven Repository: com.amazonaws:aws-java-sdk-redshiftApache HiveProperties      Name    Value        default.driver    org.apache.hive.jdbc.HiveDriver        default.url    jdbc:hive2://localhost:10000        default.user    hive_user        default.password    hive_password        hive.proxy.user    true or falseConnection to Hive JDBC with a proxy user can be disabled with hive.proxy.user property (set to true by default)Apache Hive 1 JDBC Driver DocsApache Hive 2 JDBC Driver DocsDependencies      Artifact    Excludes        org.apache.hive:hive-jdbc:0.14.0            org.apache.hadoop:hadoop-common:2.6.0    
   Maven Repository : org.apache.hive:hive-jdbcApache PhoenixPhoenix supports thick and thin connection types:Thick client is faster, but must connect directly to ZooKeeper and HBase RegionServers.Thin client has fewer dependencies and connects through a Phoenix Query Server instance.Use the appropriate default.driver, default.url, and the dependency artifact for your connection type.Thick client connectionProperties      Name    Value        default.driver    org.apache.phoenix.jdbc.PhoenixDriver        default.url    jdbc:phoenix:localhost:2181:/hbase-unsecure        default.user    phoenix_user        default.password    phoenix_password  Dependencies      Artifact    Excludes        org.apache.phoenix:phoenix-core:4.4.0-HBase-1.0      Maven Repository: org.apache.phoenix:phoenix-coreThin client connectionProperties      Name    Value        default.driver    org.apache.phoenix.queryserver.client.Driver        default.url    jdbc:phoenix:thin:url=http://localhost:8765;serializatio
 n=PROTOBUF        default.user    phoenix_user        default.password    phoenix_password  DependenciesBefore Adding one of the below dependencies, check the Phoenix version first.      Artifact    Excludes    Description        org.apache.phoenix:phoenix-server-client:4.7.0-HBase-1.1        For Phoenix 4.7        org.apache.phoenix:phoenix-queryserver-client:4.8.0-HBase-1.2        For Phoenix 4.8+  Maven Repository: org.apache.phoenix:phoenix-queryserver-clientApache TajoProperties      Name    Value        default.driver    org.apache.tajo.jdbc.TajoDriver        default.url    jdbc:tajo://localhost:26002/default  Apache Tajo JDBC Driver DocsDependencies      Artifact    Excludes        org.apache.tajo:tajo-jdbc:0.11.0      Maven Repository: org.apache.tajo:tajo-jdbcBug reportingIf you find a bug using JDBC interpreter, please create a JIRA ticket.",
+      "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.-->Generic JDBC Interpreter for Apache ZeppelinOverviewJDBC interpreter lets you create a JDBC connection to any data sources seamlessly.Inserts, Updates, and Upserts are applied immediately after running each statement.By now, it has been tested with:                    Postgresql -      JDBC Driver              Mysql -      JDBC Driver              MariaDB -      JDBC Driver              Redshift -      JDBC Driver              Apac
 he Hive -       JDBC Driver              Apache Phoenix itself is a JDBC driver              Apache Drill -       JDBC Driver              Apache Tajo -       JDBC Driver      If you are using other databases not in the above list, please feel free to share your use case. It would be helpful to improve the functionality of JDBC interpreter.Create a new JDBC InterpreterFirst, click + Create button at the top-right corner in the interpreter setting page.Fill Interpreter name field with whatever you want to use as the alias(e.g. mysql, mysql2, hive, redshift, and etc..). Please note that this alias will be used as %interpreter_name to call the interpreter in the paragraph. Then select jdbc as an Interpreter group. The default driver of JDBC interpreter is set as PostgreSQL. It means Zeppelin includes PostgreSQL driver jar in itself.So you don't need to add any dependencies(e.g. the artifact name or path for PostgreSQL driver jar) for PostgreSQL connection.The JDBC interpreter p
 roperties are defined by default like below.      Name    Default Value    Description        common.max_count    1000    The maximun number of SQL result to display        default.driver    org.postgresql.Driver    JDBC Driver Name        default.password        The JDBC user password        default.url    jdbc:postgresql://localhost:5432/    The URL for JDBC        default.user    gpadmin    The JDBC user name        default.precode        Some SQL which executes every time after initialization of the interpreter (see [Binding mode](../manual/interpreters.md#interpreter-binding-mode))        default.completer.schemaFilters        Сomma separated schema (schema = catalog = database) filters to get metadata for completions. Supports '%' symbol is equivalent to any set of characters. (ex. prod_v_%,public%,info)  If you want to connect other databases such as Mysql, Redshift and Hive, you need to edit the property values.You can also use Credential for JDBC authentication.I
 f default.user and default.password properties are deleted(using X button) for database connection in the interpreter setting page,the JDBC interpreter will get the account information from Credential.The below example is for Mysql connection.The last step is Dependency Setting. Since Zeppelin only includes PostgreSQL driver jar by default, you need to add each driver's maven coordinates or JDBC driver's jar file path for the other databases.That's it. You can find more JDBC connection setting examples(Mysql, MariaDB, Redshift, Apache Hive, Apache Phoenix, and Apache Tajo) in this section.More propertiesThere are more JDBC interpreter properties you can specify like below.      Property Name    Description        common.max_result    Max number of SQL result to display to prevent the browser overload. This is  common properties for all connections        zeppelin.jdbc.auth.type    Types of authentications' methods supported are SIMPLE, and KERBEROS       
  zeppelin.jdbc.principal    The principal name to load from the keytab        zeppelin.jdbc.keytab.location    The path to the keytab file          zeppelin.jdbc.auth.kerberos.proxy.enable      When auth type is Kerberos, enable/disable Kerberos proxy with the login user to get the connection. Default value is true.        default.jceks.file    jceks store path (e.g: jceks://file/tmp/zeppelin.jceks)        default.jceks.credentialKey    jceks credential key  You can also add more properties by using this method.For example, if a connection needs a schema parameter, it would have to add the property as follows:      name    value        default.schema    schema_name  Binding JDBC interpter to notebookTo bind the interpreters created in the interpreter setting page, click the gear icon at the top-right corner.Select(blue) or deselect(white) the interpreter buttons depending on your use cases.If you need to use more than one interpreter in the notebook, activate several buttons.Don&amp
 ;#39;t forget to click Save button, or you will face Interpreter *** is not found error.How to useRun the paragraph with JDBC interpreterTo test whether your databases and Zeppelin are successfully connected or not, type %jdbc_interpreter_name(e.g. %mysql) at the top of the paragraph and run show databases.%jdbc_interpreter_nameshow databasesIf the paragraph is FINISHED without any errors, a new paragraph will be automatically added after the previous one with %jdbc_interpreter_name.So you don't need to type this prefix in every paragraphs' header.Apply Zeppelin Dynamic FormsYou can leverage Zeppelin Dynamic Form inside your queries. You can use both the text input and select form parametrization features.%jdbc_interpreter_nameSELECT name, country, performerFROM demo.performersWHERE name='{{performer=Sheryl Crow|Doof|Fanfarlo|Los Paranoia}}'Usage precodeYou can set precode for each data source. Code runs once while opening the connection.PropertiesAn 
 example settings of interpreter for the two data sources, each of which has its precode parameter.      Property Name    Value        default.driver    org.postgresql.Driver        default.password    1        default.url    jdbc:postgresql://localhost:5432/        default.user    postgres        default.precode    set search_path='test_path'        mysql.driver    com.mysql.jdbc.Driver        mysql.password    1        mysql.url    jdbc:mysql://localhost:3306/        mysql.user    root        mysql.precode    set @v=12  UsageTest of execution precode for each data source.%jdbcshow search_pathReturns value of search_path which is set in the default.precode.%jdbc(mysql)select @vReturns value of v which is set in the mysql.precode.ExamplesHere are some examples you can refer to. Including the below connectors, you can connect every databases as long as it can be configured with it's JDBC driver.PostgresProperties      Name    Value        default.driver    org.postgres
 ql.Driver        default.url    jdbc:postgresql://localhost:5432/        default.user    mysql_user        default.password    mysql_password  Postgres JDBC Driver DocsDependencies      Artifact    Excludes        org.postgresql:postgresql:9.4.1211      Maven Repository: org.postgresql:postgresqlMysqlProperties      Name    Value        default.driver    com.mysql.jdbc.Driver        default.url    jdbc:mysql://localhost:3306/        default.user    mysql_user        default.password    mysql_password  Mysql JDBC Driver DocsDependencies      Artifact    Excludes        mysql:mysql-connector-java:5.1.38      Maven Repository: mysql:mysql-connector-javaMariaDBProperties      Name    Value        default.driver    org.mariadb.jdbc.Driver        default.url    jdbc:mariadb://localhost:3306        default.user    mariadb_user        default.password    mariadb_password  MariaDB JDBC Driver DocsDependencies      Artifact    Excludes        org.mariadb.jdbc:mariadb-java-client:1.5.4      Ma
 ven Repository: org.mariadb.jdbc:mariadb-java-clientRedshiftProperties      Name    Value        default.driver    com.amazon.redshift.jdbc42.Driver        default.url    jdbc:redshift://your-redshift-instance-address.redshift.amazonaws.com:5439/your-database        default.user    redshift_user        default.password    redshift_password  AWS Redshift JDBC Driver DocsDependencies      Artifact    Excludes        com.amazonaws:aws-java-sdk-redshift:1.11.51      Maven Repository: com.amazonaws:aws-java-sdk-redshiftApache HiveProperties      Name    Value        default.driver    org.apache.hive.jdbc.HiveDriver        default.url    jdbc:hive2://localhost:10000        default.user    hive_user        default.password    hive_password        default.proxy.user.property    Example value: hive.server2.proxy.user  Apache Hive 1 JDBC Driver DocsApache Hive 2 JDBC Driver DocsDependencies      Artifact    Excludes        org.apache.hive:hive-jdbc:0.14.0            org.apache.hadoop:hadoop-c
 ommon:2.6.0      Maven Repository : org.apache.hive:hive-jdbcImpersonationWhen Zeppelin server is running with authentication enabled, then the interpreter can utilize Hive's user proxy feature i.e. send extra parameter for creating and running a session ("hive.server2.proxy.user=": "${loggedInUser}"). This is particularly useful when multiple users are sharing a notebook.To enable this set following:zeppelin.jdbc.auth.type as SIMPLE or KERBEROS (if required) in the interpreter setting.${prefix}.proxy.user.property as hive.server2.proxy.userSample configuration      Name    Value        hive.driver    org.apache.hive.jdbc.HiveDriver        hive.password            hive.url    jdbc:hive2://hive-server-host:2181/;serviceDiscoveryMode=zooKeeper;zooKeeperNamespace=hiveserver2        hive.proxy.user.property    hive.server2.proxy.user        zeppelin.jdbc.auth.type    SIMPLE  Apache PhoenixPhoenix supports thick and thin connection types:Thick 
 client is faster, but must connect directly to ZooKeeper and HBase RegionServers.Thin client has fewer dependencies and connects through a Phoenix Query Server instance.Use the appropriate default.driver, default.url, and the dependency artifact for your connection type.Thick client connectionProperties      Name    Value        default.driver    org.apache.phoenix.jdbc.PhoenixDriver        default.url    jdbc:phoenix:localhost:2181:/hbase-unsecure        default.user    phoenix_user        default.password    phoenix_password  Dependencies      Artifact    Excludes        org.apache.phoenix:phoenix-core:4.4.0-HBase-1.0      Maven Repository: org.apache.phoenix:phoenix-coreThin client connectionProperties      Name    Value        default.driver    org.apache.phoenix.queryserver.client.Driver        default.url    jdbc:phoenix:thin:url=http://localhost:8765;serialization=PROTOBUF        default.user    phoenix_user        default.password    phoenix_password  DependenciesBefore Addi
 ng one of the below dependencies, check the Phoenix version first.      Artifact    Excludes    Description        org.apache.phoenix:phoenix-server-client:4.7.0-HBase-1.1        For Phoenix 4.7        org.apache.phoenix:phoenix-queryserver-client:4.8.0-HBase-1.2        For Phoenix 4.8+  Maven Repository: org.apache.phoenix:phoenix-queryserver-clientApache TajoProperties      Name    Value        default.driver    org.apache.tajo.jdbc.TajoDriver        default.url    jdbc:tajo://localhost:26002/default  Apache Tajo JDBC Driver DocsDependencies      Artifact    Excludes        org.apache.tajo:tajo-jdbc:0.11.0      Maven Repository: org.apache.tajo:tajo-jdbcBug reportingIf you find a bug using JDBC interpreter, please create a JIRA ticket.",
       "url": " /interpreter/jdbc.html",
       "group": "interpreter",
       "excerpt": "Generic JDBC Interpreter lets you create a JDBC connection to any data source. You can use Postgres, MySql, MariaDB, Redshift, Apache Hive, Apache Phoenix, Apache Drill and Apache Tajo using JDBC interpreter."
@@ -512,7 +512,7 @@
 
     "/manual/dynamicform.html": {
       "title": "Dynamic Form 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.-->Dynamic FormApache Zeppelin dynamically creates input forms. Depending on language backend, there're two different ways to create dynamic form.Custom language backend can select which type of form creation it wants to use.Using form TemplatesThis mode creates form using simple template language. It's simple and easy to use. For example Markdown, Shell, Spark SQL language backend uses it.Text input formTo create text
  input form, use ${formName} templates.for exampleAlso you can provide default value, using ${formName=defaultValue}.Select formTo create select form, use ${formName=defaultValue,option1|option2...}for exampleAlso you can separate option's display name and value, using ${formName=defaultValue,option1(DisplayName)|option2(DisplayName)...}The paragraph will be automatically run after you change your selection by default.But in case you have multiple types dynamic form in one paragraph, you might want to run the paragraph after changing all the selections.You can control this by unchecking the below Run on selection change option in the setting menu.Even if you uncheck this option, still you can run it by pressing Enter.Checkbox formFor multi-selection, you can create a checkbox form using ${checkbox:formName=defaultValue1|defaultValue2...,option1|option2...}. The variable will be substituted by a comma-separated string based on the selected items. For example:Besides, you can 
 specify the delimiter using ${checkbox(delimiter):formName=...}:Like select form, the paragraph will be automatically run after you change your selection by default.But in case you have multiple types dynamic form in one paragraph, you might want to run the paragraph after changing all the selections.You can control this by unchecking the below Run on selection change option in the setting menu.Even if you uncheck this option, still you can run it by pressing Enter.Creates ProgrammaticallySome language backend uses programmatic way to create form. For example ZeppelinContext provides form creation APIHere're some examples.Text input form    %sparkprintln("Hello "+z.input("name"))        %pysparkprint("Hello "+z.input("name"))    Text input form with default value    %sparkprintln("Hello "+z.input("name", "sun"))         %pysparkprint("Hello &
 amp;quot;+z.input("name", "sun"))    Select form    %sparkprintln("Hello "+z.select("day", Seq(("1","mon"),                                    ("2","tue"),                                    ("3","wed"),                                    ("4","thurs"),                                    ("5","fri"),                                    ("6","sat"),                                    ("7","sun"))))        %pysparkprint("Hello "+z.select("day", [("1","mon"),                                ("2","tue"),                                ("3",&qu
 ot;wed"),                                ("4","thurs"),                                ("5","fri"),                                ("6","sat"),                                ("7","sun")]))    Checkbox form    %sparkval options = Seq(("apple","Apple"), ("banana","Banana"), ("orange","Orange"))println("Hello "+z.checkbox("fruit", options).mkString(" and "))        %pysparkoptions = [("apple","Apple"), ("banana","Banana"), ("orange","Orange")]print("Hello "+ " and ".join(z.checkbox("fruit", options, ["apple&
 amp;quot;])))    ",
+      "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.-->Dynamic FormApache Zeppelin dynamically creates input forms. Depending on language backend, there're two different ways to create dynamic form.Custom language backend can select which type of form creation it wants to use.Using form TemplatesThis mode creates form using simple template language. It's simple and easy to use. For example Markdown, Shell, Spark SQL language backend uses it.Text input formTo create text
  input form, use ${formName} templates.for exampleAlso you can provide default value, using ${formName=defaultValue}.Select formTo create select form, use ${formName=defaultValue,option1|option2...}for exampleAlso you can separate option's display name and value, using ${formName=defaultValue,option1(DisplayName)|option2(DisplayName)...}The paragraph will be automatically run after you change your selection by default.But in case you have multiple types dynamic form in one paragraph, you might want to run the paragraph after changing all the selections.You can control this by unchecking the below Run on selection change option in the setting menu.Even if you uncheck this option, still you can run it by pressing Enter.Checkbox formFor multi-selection, you can create a checkbox form using ${checkbox:formName=defaultValue1|defaultValue2...,option1|option2...}. The variable will be substituted by a comma-separated string based on the selected items. For example:You can specify t
 he delimiter using ${checkbox(delimiter):formName=...}:Like select form, the paragraph will be automatically run after you change your selection by default.But in case you have multiple types dynamic form in one paragraph, you might want to run the paragraph after changing all the selections.You can control this by unchecking the below Run on selection change option in the setting menu.Even if you uncheck this option, still you can run it by pressing Enter.Creates ProgrammaticallySome language backends can programmatically create forms. For example ZeppelinContext provides a form creation APIHere are some examples:Text input form    %sparkprintln("Hello "+z.input("name"))        %pysparkprint("Hello "+z.input("name"))    Text input form with default value    %sparkprintln("Hello "+z.input("name", "sun"))         %pysparkprint("Hello "+z.inpu
 t("name", "sun"))    Select form    %sparkprintln("Hello "+z.select("day", Seq(("1","mon"),                                    ("2","tue"),                                    ("3","wed"),                                    ("4","thurs"),                                    ("5","fri"),                                    ("6","sat"),                                    ("7","sun"))))        %pysparkprint("Hello "+z.select("day", [("1","mon"),                                ("2","tue"),                                ("3","wed"
 ),                                ("4","thurs"),                                ("5","fri"),                                ("6","sat"),                                ("7","sun")]))    Checkbox form    %sparkval options = Seq(("apple","Apple"), ("banana","Banana"), ("orange","Orange"))println("Hello "+z.checkbox("fruit", options).mkString(" and "))        %pysparkoptions = [("apple","Apple"), ("banana","Banana"), ("orange","Orange")]print("Hello "+ " and ".join(z.checkbox("fruit", options, ["apple"])))   
  ",
       "url": " /manual/dynamicform.html",
       "group": "manual",
       "excerpt": "Apache Zeppelin dynamically creates input forms. Depending on language backend, there're two different ways to create dynamic form."
@@ -556,7 +556,7 @@
 
     "/manual/interpreters.html": {
       "title": "Interpreters 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.-->Interpreters in Apache ZeppelinOverviewIn this section, we will explain about the role of interpreters, interpreters group and interpreter settings in Zeppelin.The concept of Zeppelin interpreter allows any language/data-processing-backend to be plugged into Zeppelin.Currently, Zeppelin supports many interpreters such as Scala ( with Apache Spark ), Python ( with Apache Spark ), Spark SQL, JDBC, Markdown, Shell and so on.What is Ze
 ppelin interpreter?Zeppelin Interpreter is a plug-in which enables Zeppelin users to use a specific language/data-processing-backend. For example, to use Scala code in Zeppelin, you need %spark interpreter.When you click the +Create button in the interpreter page, the interpreter drop-down list box will show all the available interpreters on your server.What is interpreter setting?Zeppelin interpreter setting is the configuration of a given interpreter on Zeppelin server. For example, the properties are required for hive JDBC interpreter to connect to the Hive server.Properties are exported as environment variables when property name is consisted of upper characters, numbers and underscore ([A-Z_0-9]). Otherwise set properties as JVM property. You may use parameters from the context of interpreter by add #{contextParameterName} in value, parameter can be of the following types: string, number, boolean.Context parameters      Name    Type        user    string        noteId    string
         replName    string        className    string  If context parameter is null then replaced by empty string.Each notebook can be bound to multiple Interpreter Settings using setting icon on upper right corner of the notebook.What is interpreter group?Every Interpreter is belonged to an Interpreter Group. Interpreter Group is a unit of start/stop interpreter.By default, every interpreter is belonged to a single group, but the group might contain more interpreters. For example, Spark interpreter group is including Spark support, pySpark, Spark SQL and the dependency loader.Technically, Zeppelin interpreters from the same group are running in the same JVM. For more information about this, please checkout here.Each interpreters is belonged to a single group and registered together. All of their properties are listed in the interpreter setting like below image.Interpreter binding modeEach Interpreter Setting can choose one of 'shared', 'scoped', &amp
 ;#39;isolated' interpreter binding mode.In 'shared' mode, every notebook bound to the Interpreter Setting will share the single Interpreter instance. In 'scoped' mode, each notebook will create new Interpreter instance in the same interpreter process. In 'isolated' mode, each notebook will create new Interpreter process.Connecting to the existing remote interpreterZeppelin users can start interpreter thread embedded in their service. This will provide flexibility to user to start interpreter on remote host. To start interpreter along with your service you have to create an instance of RemoteInterpreterServer and start it as follows:RemoteInterpreterServer interpreter=new RemoteInterpreterServer(3678); // Here, 3678 is the port on which interpreter will listen.    interpreter.start()  The above code will start interpreter thread inside your process. Once the interpreter is started you can configure zeppelin to connect to RemoteI
 nterpreter by checking Connect to existing process checkbox and then provide Host and Port on which interpreter process is listening as shown in the image below:",
+      "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.-->Interpreters in Apache ZeppelinOverviewIn this section, we will explain about the role of interpreters, interpreters group and interpreter settings in Zeppelin.The concept of Zeppelin interpreter allows any language/data-processing-backend to be plugged into Zeppelin.Currently, Zeppelin supports many interpreters such as Scala ( with Apache Spark ), Python ( with Apache Spark ), Spark SQL, JDBC, Markdown, Shell and so on.What is Ze
 ppelin interpreter?Zeppelin Interpreter is a plug-in which enables Zeppelin users to use a specific language/data-processing-backend. For example, to use Scala code in Zeppelin, you need %spark interpreter.When you click the +Create button in the interpreter page, the interpreter drop-down list box will show all the available interpreters on your server.What is interpreter setting?Zeppelin interpreter setting is the configuration of a given interpreter on Zeppelin server. For example, the properties are required for hive JDBC interpreter to connect to the Hive server.Properties are exported as environment variables when property name is consisted of upper characters, numbers and underscore ([A-Z_0-9]). Otherwise set properties as JVM property. You may use parameters from the context of interpreter by add #{contextParameterName} in value, parameter can be of the following types: string, number, boolean.Context parameters      Name    Type        user    string        noteId    string
         replName    string        className    string  If context parameter is null then replaced by empty string.Each notebook can be bound to multiple Interpreter Settings using setting icon on upper right corner of the notebook.What is interpreter group?Every Interpreter is belonged to an Interpreter Group. Interpreter Group is a unit of start/stop interpreter.By default, every interpreter is belonged to a single group, but the group might contain more interpreters. For example, Spark interpreter group is including Spark support, pySpark, Spark SQL and the dependency loader.Technically, Zeppelin interpreters from the same group are running in the same JVM. For more information about this, please checkout here.Each interpreters is belonged to a single group and registered together. All of their properties are listed in the interpreter setting like below image.Interpreter binding modeEach Interpreter Setting can choose one of 'shared', 'scoped', &amp
 ;#39;isolated' interpreter binding mode.In 'shared' mode, every notebook bound to the Interpreter Setting will share the single Interpreter instance. In 'scoped' mode, each notebook will create new Interpreter instance in the same interpreter process. In 'isolated' mode, each notebook will create new Interpreter process.Connecting to the existing remote interpreterZeppelin users can start interpreter thread embedded in their service. This will provide flexibility to user to start interpreter on remote host. To start interpreter along with your service you have to create an instance of RemoteInterpreterServer and start it as follows:RemoteInterpreterServer interpreter=new RemoteInterpreterServer(3678); // Here, 3678 is the port on which interpreter will listen.    interpreter.start()  The above code will start interpreter thread inside your process. Once the interpreter is started you can configure zeppelin to connect to RemoteI
 nterpreter by checking Connect to existing process checkbox and then provide Host and Port on which interpreter process is listening as shown in the image below:PrecodeSnippet of code (language of interpreter) that executes after initialization of the interpreter depends on Binding mode. To configure add parameter with class of interpreter (zeppelin.<ClassName>.precode) except JDBCInterpreter (JDBC precode). ",
       "url": " /manual/interpreters.html",
       "group": "manual",
       "excerpt": "This document explains about the role of interpreters, interpreters group and interpreter settings in Apache Zeppelin. The concept of Zeppelin interpreter allows any language/data-processing-backend to be plugged into Zeppelin."
@@ -601,7 +601,7 @@
 
     "/quickstart/explorezeppelinui.html": {
       "title": "Explore Apache Zeppelin UI",
-      "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.-->Explore Apache Zeppelin UIMain homeThe first time you connect to Zeppelin, you'll land at the main page similar to the below screen capture.On the left of the page are listed all existing notes. Those notes are stored by default in the $ZEPPELIN_HOME/notebook folder.You can filter them by name using the input text form. You can also create a new note, refresh the list of existing notes(in case you manually copy them into th
 e $ZEPPELIN_HOME/notebook folder) and import a note.When clicking on Import Note link, a new dialog open. From there you can import your note from local disk or from a remote locationif you provide the URL.By default, the name of the imported note is the same as the original note but you can override it by providing a new name.MenusNotebookThe Notebook menu proposes almost the same features as the note management section in the home page. From the drop-down menu you can:Open a selected noteFilter node by nameCreate a new noteSettingsThis menu gives you access to settings and displays information about Zeppelin. User name is set to anonymous if you use default shiro configuration. If you want to set up authentification, see Shiro authentication.About ZeppelinYou can check Zeppelin version in this menu.InterpreterIn this menu you can:Configure existing interpreter instanceAdd/remove interpreter instancesCredentialThis menu allows you to save credentials for data sources which are pass
 ed to interpreters.ConfigurationThis menu displays all the Zeppelin configuration that are set in the config file $ZEPPELIN_HOME/conf/zeppelin-site.xmlNote LayoutEach Zeppelin note is composed of 1 .. N paragraphs. The note can be viewed as a paragraph container.ParagraphEach paragraph consists of 2 sections: code section where you put your source code and result section where you can see the result of the code execution.On the top-right corner of each paragraph there are some commands to:execute the paragraph codehide/show code sectionhide/show result sectionconfigure the paragraphTo configure the paragraph, just click on the gear icon:From this dialog, you can (in descending order):find the paragraph id ( 20150924-163507_134879501 )control paragraph width. Since Zeppelin is using the grid system of Twitter Bootstrap, each paragraph width can be changed from 1 to 12move the paragraph 1 level upmove the paragraph 1 level downcreate a new paragraphchange paragraph titleshow/hide line
  number in the code sectiondisable the run button for this paragraphexport the current paragraph as an iframe and open the iframe in a new windowclear the result sectiondelete the current paragraphNote toolbarAt the top of the note, you can find a toolbar which exposes command buttons as well as configuration, security and display options.On the far right is displayed the note name, just click on it to reveal the input form and update it.In the middle of the toolbar you can find the command buttons:execute all the paragraphs sequentially, in their display orderhide/show code section of all paragraphshide/show result section of all paragraphsclear the result section of all paragraphsclone the current noteexport the current note to a JSON file. _Please note that the code section and result section of all paragraphs will be exported. If you have heavy data in the result section of some paragraphs, it is recommended to clean them before exportingcommit the current node contentdelete the
  noteschedule the execution of all paragraph using a CRON syntaxOn the right of the note tool bar you can find configuration icons:display all the keyboard shorcutsconfigure the interpreters binding to the current noteconfigure the note permissionsswitch the node display mode between default, simple and report",
+      "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.-->Explore Apache Zeppelin UIMain homeThe first time you connect to Zeppelin (default installations start on http://localhost:8080), you'll land at the main page similar to the below screen capture.On the left of the page are listed all existing notes. Those notes are stored by default in the $ZEPPELIN_HOME/notebook folder.You can filter them by name using the input text form. You can also create a new note, refresh the list o
 f existing notes(in case you manually copy them into the $ZEPPELIN_HOME/notebook folder) and import a note.When clicking on Import Note link, a new dialog open. From there you can import your note from local disk or from a remote locationif you provide the URL.By default, the name of the imported note is the same as the original note but you can override it by providing a new name.MenusNotebookThe Notebook menu proposes almost the same features as the note management section in the home page. From the drop-down menu you can:Open a selected noteFilter node by nameCreate a new noteSettingsThis menu gives you access to settings and displays information about Zeppelin. User name is set to anonymous if you use default shiro configuration. If you want to set up authentification, see Shiro authentication.About ZeppelinYou can check Zeppelin version in this menu.InterpreterIn this menu you can:Configure existing interpreter instanceAdd/remove interpreter instancesCredentialThis menu allows 
 you to save credentials for data sources which are passed to interpreters.ConfigurationThis menu displays all the Zeppelin configuration that are set in the config file $ZEPPELIN_HOME/conf/zeppelin-site.xmlNote LayoutEach Zeppelin note is composed of 1 .. N paragraphs. The note can be viewed as a paragraph container.ParagraphEach paragraph consists of 2 sections: code section where you put your source code and result section where you can see the result of the code execution.On the top-right corner of each paragraph there are some commands to:execute the paragraph codehide/show code sectionhide/show result sectionconfigure the paragraphTo configure the paragraph, just click on the gear icon:From this dialog, you can (in descending order):find the paragraph id ( 20150924-163507_134879501 )control paragraph width. Since Zeppelin is using the grid system of Twitter Bootstrap, each paragraph width can be changed from 1 to 12move the paragraph 1 level upmove the paragraph 1 level downcre
 ate a new paragraphchange paragraph titleshow/hide line number in the code sectiondisable the run button for this paragraphexport the current paragraph as an iframe and open the iframe in a new windowclear the result sectiondelete the current paragraphNote toolbarAt the top of the note, you can find a toolbar which exposes command buttons as well as configuration, security and display options.On the far right is displayed the note name, just click on it to reveal the input form and update it.In the middle of the toolbar you can find the command buttons:execute all the paragraphs sequentially, in their display orderhide/show code section of all paragraphshide/show result section of all paragraphsclear the result section of all paragraphsclone the current noteexport the current note to a JSON file. _Please note that the code section and result section of all paragraphs will be exported. If you have heavy data in the result section of some paragraphs, it is recommended to clean them be
 fore exportingcommit the current node contentdelete the noteschedule the execution of all paragraph using a CRON syntaxOn the right of the note tool bar you can find configuration icons:display all the keyboard shorcutsconfigure the interpreters binding to the current noteconfigure the note permissionsswitch the node display mode between default, simple and report",
       "url": " /quickstart/explorezeppelinui.html",
       "group": "quickstart",
       "excerpt": "If you are new to Apache Zeppelin, this document will guide you about the basic components of Zeppelin one by one."
@@ -737,7 +737,7 @@
 
     "/security/shiroauthentication.html": {
       "title": "Apache Shiro Authentication for Apache Zeppelin",

[... 6 lines stripped ...]
Modified: zeppelin/site/docs/0.8.0-SNAPSHOT/security/shiroauthentication.html
URL: http://svn.apache.org/viewvc/zeppelin/site/docs/0.8.0-SNAPSHOT/security/shiroauthentication.html?rev=1795220&r1=1795219&r2=1795220&view=diff
==============================================================================
--- zeppelin/site/docs/0.8.0-SNAPSHOT/security/shiroauthentication.html (original)
+++ zeppelin/site/docs/0.8.0-SNAPSHOT/security/shiroauthentication.html Mon May 15 15:03:55 2017
@@ -272,13 +272,14 @@ activeDirectoryRealm.searchBase = CN=Use
 activeDirectoryRealm.url = ldap://ldap.test.com:389
 activeDirectoryRealm.groupRolesMap = "CN=aGroupName,OU=groups,DC=SOME_GROUP,DC=COMPANY,DC=COM":"group1"
 activeDirectoryRealm.authorizationCachingEnabled = false
+activeDirectoryRealm.principalSuffix = @corp.company.net
 
 ldapRealm = org.apache.zeppelin.server.LdapGroupRealm
 # search base for ldap groups (only relevant for LdapGroupRealm):
 ldapRealm.contextFactory.environment[ldap.searchBase] = dc=COMPANY,dc=COM
 ldapRealm.contextFactory.url = ldap://ldap.test.com:389
 ldapRealm.userDnTemplate = uid={0},ou=Users,dc=COMPANY,dc=COM
-ldapRealm.contextFactory.authenticationMechanism = SIMPLE
+ldapRealm.contextFactory.authenticationMechanism = simple
 </code></pre></div>
 <p>also define roles/groups that you want to have in system, like below;</p>
 <div class="highlight"><pre><code class="text language-text" data-lang="text">[roles]
@@ -303,6 +304,7 @@ activeDirectoryRealm.searchBase = CN=Use
 activeDirectoryRealm.url = ldap://ldap.test.com:389
 activeDirectoryRealm.groupRolesMap = &quot;CN=aGroupName,OU=groups,DC=SOME_GROUP,DC=COMPANY,DC=COM&quot;:&quot;group1&quot;
 activeDirectoryRealm.authorizationCachingEnabled = false
+activeDirectoryRealm.principalSuffix = @corp.company.net
 </code></pre></div>
 <p>Also instead of specifying systemPassword in clear text in shiro.ini administrator can choose to specify the same in &quot;hadoop credential&quot;.
 Create a keystore file using the hadoop credential commandline, for this the hadoop commons should be in the classpath
@@ -317,7 +319,7 @@ Create a keystore file using the hadoop
 ldapRealm.contextFactory.environment[ldap.searchBase] = dc=COMPANY,dc=COM
 ldapRealm.contextFactory.url = ldap://ldap.test.com:389
 ldapRealm.userDnTemplate = uid={0},ou=Users,dc=COMPANY,dc=COM
-ldapRealm.contextFactory.authenticationMechanism = SIMPLE
+ldapRealm.contextFactory.authenticationMechanism = simple
 </code></pre></div>
 <h3>PAM</h3>