diff --git a/examples/Examples.ipynb b/examples/Examples.ipynb
index 6cb5ac3bfd78b0c34cce9ae8bf3beae13bd190e4..a16493483fa08f806f433586b26ead8049943b26 100644
--- a/examples/Examples.ipynb
+++ b/examples/Examples.ipynb
@@ -4,11 +4,11 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "## Content\n",
- "- [SimpleRenderer](#SimpleRenderer)\n",
- "- [Sizing](#Sizing)\n",
- "- [RemoteRenderer](#RemoteRenderer)\n",
- " - [Default Usage](#Usage)\n",
+ "# Content\n",
+ "1. [SimpleRenderer](#SimpleRenderer)\n",
+ "2. [Sizing](#Sizing)\n",
+ "3. [RemoteRenderer](#RemoteRenderer)\n",
+ " 1. [Default Behaviour](#Default-Behaviour)\n",
" - [Fixed views](#Fixed-views)\n",
" - [Using Jupyter Server Proxy](#Using-Jupyter-Server-Proxy)\n",
" - [Using a custom protocol](#Using-a-custom-protocol)\n",
@@ -33,7 +33,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Start a ParaViewWeb server application over the command line (see the [ParaView example](https://kitware.github.io/paraviewweb/examples/RemoteRenderer.html#Using-ParaView-as-server))\n",
+ "Start a ParaViewWeb server application over the command line (see the [official ParaViewWeb example](https://kitware.github.io/paraviewweb/examples/RemoteRenderer.html#Using-ParaView-as-server))\n",
"```bash\n",
"pvpython pv_server.py --port 1234 --authKey wslink-secret \n",
"```"
@@ -56,7 +56,7 @@
"metadata": {},
"source": [
"# Sizing\n",
- "Widgets scales with container size."
+ "Widgets scale with container size."
]
},
{
@@ -67,7 +67,7 @@
"source": [
"from ipywidgets import Box\n",
"\n",
- "Box(children=[simple], layout={'height':'500px'})"
+ "Box(children=[simple], layout={'height':'800px'})"
]
},
{
@@ -78,17 +78,70 @@
"\n",
"This renderer requires the `paraview.simple` and `paraview.web` modules.\n",
"\n",
- "Upon initialization, the RemoteRenderer starts a webserver for you. If nothing is specified, the webserver will try to start on port 8080 or the next free port thereafter and create a random authentication key. You can pass your own arguments to the webserver. To display help on the possible arguments, you can call `<yourRenderer>.webserver_arguments_help()`.\n",
+ "## Default Behaviour\n",
"\n",
- "If `pvserver_host` and `pvserver_port` (default 11111) are specified, the webserver will try to establish a connection to the ParaView server (pvserver) at the given host and port. The pvserver can then take over the heavy lifting and handle very large geometries. Locally, only the image data of the processed data is recieved. To prevent data from being rendered locally, we recommend using the `SetRecommendedRenderSettings` function from `pvlink.utilities` on your displayed view."
+ "Upon initialization, the RemoteRenderer starts a webserver for you. If nothing is specified, the webserver will try to start on port 8080 or the next free port thereafter and create a random authentication key. You can pass your own arguments to the webserver. To display help on the possible arguments, you can call `RemoteRenderer.webserver_arguments_help()`.\n",
+ "\n",
+ "Arguments that do not take a value need to be set to True. \n",
+ "\n",
+ "**Example:** `debug=True` corresponds to `--debug`"
]
},
{
- "cell_type": "markdown",
+ "cell_type": "code",
+ "execution_count": 1,
"metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "ParaView Web Server\n",
+ "\n",
+ "optional arguments:\n",
+ " -h, --help show this help message and exit\n",
+ " -d, --debug log debugging messages to stdout\n",
+ " -s, --nosignalhandlers\n",
+ " Prevent Twisted to install the signal handlers so it\n",
+ " can be started inside a thread.\n",
+ " -i HOST, --host HOST the interface for the web-server to listen on\n",
+ " (default: localhost)\n",
+ " -p PORT, --port PORT port number for the web-server to listen on (default:\n",
+ " 8080)\n",
+ " -t TIMEOUT, --timeout TIMEOUT\n",
+ " timeout for reaping process on idle in seconds\n",
+ " (default: 300s)\n",
+ " -c CONTENT, --content CONTENT\n",
+ " root for web-pages to serve (default: none)\n",
+ " -a AUTHKEY, --authKey AUTHKEY\n",
+ " Authentication key for clients to connect to the\n",
+ " WebSocket.\n",
+ " -f, --force-flush If provided, this option will force additional padding\n",
+ " content to the output. Useful when application is\n",
+ " triggered by a session manager.\n",
+ " -k SSLKEY, --sslKey SSLKEY\n",
+ " SSL key. Use this and --sslCert to start the server on\n",
+ " https.\n",
+ " -j SSLCERT, --sslCert SSLCERT\n",
+ " SSL certificate. Use this and --sslKey to start the\n",
+ " server on https.\n",
+ " -ws WS, --ws-endpoint WS\n",
+ " Specify WebSocket endpoint. (e.g. foo/bar/ws, Default:\n",
+ " ws)\n",
+ " --no-ws-endpoint If provided, disables the websocket endpoint\n",
+ " --fs-endpoints FSENDPOINTS\n",
+ " add another fs location to a specific endpoint (i.e:\n",
+ " data=/Users/seb/Download|images=/Users/seb/Pictures)\n",
+ " --upload-directory UPLOADPATH\n",
+ " path to root upload directory\n",
+ "\n"
+ ]
+ }
+ ],
"source": [
- "## Usage \n",
- "### Default"
+ "from pvlink import RemoteRenderer\n",
+ "\n",
+ "print(RemoteRenderer.webserver_arguments_help())"
]
},
{
@@ -100,9 +153,6 @@
"from pvlink import RemoteRenderer\n",
"\n",
"active_renderer = RemoteRenderer(port=8080)\n",
- "# Alternatively, if you want to render your data with a ParaView server:\n",
- "# Start a pvserver over the command line and run the following line\n",
- "# renderer = RemoteRenderer(pvserver_host='localhost', pvserver_port=11111, p=8082)\n",
"display(active_renderer)"
]
},
@@ -131,16 +181,16 @@
"source = simple.Cone()\n",
"simple.Show(source, view1)\n",
"# Update the renderer widget to display the changes\n",
- "# active_renderer.update_render()"
+ "active_renderer.update_render()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
- "### Fixed views\n",
+ "## Fixed views\n",
"\n",
- "By default, the active view (`viewID = '-1'`) will be shown in the render widget. To set the output of the widget to a fixed view, we can specify the viewID as string."
+ "By default, the active view (`viewID = \"-1\"`) will be shown in the render widget. To set the output of the widget to a fixed view, we can specify the viewID as string."
]
},
{
@@ -189,13 +239,15 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "### Using Jupyter Server Proxy\n",
+ "## Using Jupyter Server Proxy\n",
"\n",
- "If you want to access your webserver using Jupyter Server Proxy, you need to set `use_jupyter_server_proxy` to True and specify the baseURL.\n",
+ "If you want to access your webserver using Jupyter Server Proxy, you need to set `useJupyterServerProxy` to True and specify the baseURL.\n",
"\n",
"**Example:** If your notebook url is `http://localhost:8888` and you would access a process using `http://localhost:88888/proxy/8080`, the baseURL would be the part before \"proxy\", `localhost:8888`.\n",
"\n",
- "If your notebook is running on HTTPS, set `use_jupyter_server_proxy_https` to True to use the HTTPS certificates of the notebook server to keep the connection between the client browser and the jupyter Server Proxy encrypted."
+ "If your notebook is running on HTTPS, set `useJupyterServerProxyHttps` to True to use the HTTPS certificates of the notebook server to keep the connection between the client browser and the Jupyter Server Proxy encrypted.\n",
+ "\n",
+ "In both cases, `disableExternalPort` needs to be set to disable port checking during the WebSocket opening handshake. Otherwise, the connection will fail with a port mismatch error since the notebook and the webserver do not run on the same port."
]
},
{
@@ -206,7 +258,9 @@
},
"outputs": [],
"source": [
- "proxied_renderer = RemoteRenderer(baseURL='localhost:8888', disableExternalPort=True, use_jupyter_server_proxy=True, \n",
+ "proxied_renderer = RemoteRenderer(baseURL='localhost:8888', \n",
+ " disableExternalPort=True,\n",
+ " useJupyterServerProxy=True, # or useJupyterServerProxyHttps\n",
" port=8088)"
]
},
@@ -229,69 +283,6 @@
"display(proxied_renderer)"
]
},
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "You can display help for the possible webserver arugments."
- ]
- },
- {
- "cell_type": "code",
-
- "execution_count": 1,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "ParaView Web Server\n",
- "\n",
- "optional arguments:\n",
- " -h, --help show this help message and exit\n",
- " -d, --debug log debugging messages to stdout\n",
- " -s, --nosignalhandlers\n",
- " Prevent Twisted to install the signal handlers so it\n",
- " can be started inside a thread.\n",
- " -i HOST, --host HOST the interface for the web-server to listen on\n",
- " (default: localhost)\n",
- " -p PORT, --port PORT port number for the web-server to listen on (default:\n",
- " 8080)\n",
- " -t TIMEOUT, --timeout TIMEOUT\n",
- " timeout for reaping process on idle in seconds\n",
- " (default: 300s)\n",
- " -c CONTENT, --content CONTENT\n",
- " root for web-pages to serve (default: none)\n",
- " -a AUTHKEY, --authKey AUTHKEY\n",
- " Authentication key for clients to connect to the\n",
- " WebSocket.\n",
- " -f, --force-flush If provided, this option will force additional padding\n",
- " content to the output. Useful when application is\n",
- " triggered by a session manager.\n",
- " -k SSLKEY, --sslKey SSLKEY\n",
- " SSL key. Use this and --sslCert to start the server on\n",
- " https.\n",
- " -j SSLCERT, --sslCert SSLCERT\n",
- " SSL certificate. Use this and --sslKey to start the\n",
- " server on https.\n",
- " -ws WS, --ws-endpoint WS\n",
- " Specify WebSocket endpoint. (e.g. foo/bar/ws, Default:\n",
- " ws)\n",
- " --no-ws-endpoint If provided, disables the websocket endpoint\n",
- " --fs-endpoints FSENDPOINTS\n",
- " add another fs location to a specific endpoint (i.e:\n",
- " data=/Users/seb/Download|images=/Users/seb/Pictures)\n",
- " --upload-directory UPLOADPATH\n",
- " path to root upload directory\n",
- "\n"
- ]
- }
- ],
- "source": [
- "print(RemoteRenderer.webserver_arguments_help())"
- ]
- },
{
"cell_type": "markdown",
"metadata": {},
@@ -344,6 +335,8 @@
"metadata": {},
"outputs": [],
"source": [
+ "from pvlink import RemoteRenderer\n",
+ "\n",
"custom_renderer = RemoteRenderer(protocol=DemoServer, a='mysecretkey')\n",
"# Bind the viewID to the widget to avoid it showing a different view\n",
"# when a different view is set to the active view\n",
@@ -355,7 +348,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Since we did not bind a view to `renderer`, the sphere should now also be visible in the `renderer` [output](#Default) after an update call."
+ "Since we did not bind a view to `renderer`, the sphere should now also be visible in the `renderer` [output](#Default-Behaviour) after an update call."
]
},
{
@@ -371,8 +364,11 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "## Usage with a pvserver and chosen port\n",
- "This shows how to connect to a pvserver on startup and open a specific port. Additionaly debug outpout is enabled, in case an error is searched. The pvserver adress and port can be specified. This only works with the default protocol, as the connection is established there. So in case of a custom protocol, the connection to the pvserver has to be started by the user (or in the custom protocol)."
+ "## Using the webserver with a pvserver\n",
+ "\n",
+ "If `pvserverHost` and `pvserverPort` (default 11111) are specified, the webserver will try to establish a connection to a ParaView server (pvserver) at the given host and port. The pvserver can then take over the heavy lifting and handle very large geometries. Locally, only the image data of the processed data is recieved. To prevent data from being rendered locally, we recommend using the `SetRecommendedRenderSettings` function from `pvlink.utilities` on your displayed view.\n",
+ "\n",
+ "If using a custom protocol, the connection has to be created in the protocol or later on manually in the notebook by the user."
]
},
{
@@ -381,8 +377,7 @@
"metadata": {},
"outputs": [],
"source": [
- "renderer = RemoteRenderer(pvserver_host=\"localhost\", pvserver_port = 11111, baseURL=\"localhost\", ws=\"pvwebserver/ws\",\n",
- " debug=True, port = 1234)"
+ "renderer = RemoteRenderer(pvserverHost=\"localhost\", pvserverPort=11111, port=1234)"
]
}
],
diff --git a/pvlink/remoterenderer.py b/pvlink/remoterenderer.py
index 4e80383f71e10d22498ca6029f82d919fc292155..313a7787268105f258809cf7ab68cd50479a9612 100644
--- a/pvlink/remoterenderer.py
+++ b/pvlink/remoterenderer.py
@@ -42,36 +42,40 @@ class RemoteRenderer(DOMWidget):
Parameters
----------
- pvserver_host: str
- if not None, create a connection to a pvserver at the given host.
+ pvserverHost: str
+ if not None, create a connection to a pvserver at the given host
+ upon start of the ParaViewWeb server.
Default = None
- pvserver_port: str
+ pvserverPort: str
port on which the pvserver is listening
Default = 11111
+ viewID: str
+ viewID of the view to connect to
+ (only relevant if multiple views exist on the server side)
+ Default = "-1"
baseURL: str
the baseURL under which the ParaViewWeb server will be started.
If the notebook is running under `http://localhost:8888`,
the baseURL would be `localhost`.
If Jupyter Server Proxy is being used, the baseURL is the part
- in front of 'proxy'. So if your notebook url is `http://localhost:8888`
- and you would access a process using `http://localhost:88888/proxy/8080`,
+ in front of "proxy". So if your notebook url is `http://localhost:8888`
+ and you would access a process using `http://localhost:8888/proxy/8080`,
the baseURL would be `localhost:8888`.
Default = "localhost"
- viewID: str
- viewID of the view to connect to (only relevant if multiple views exist on the server side)
- Default = "-1"
- use_jupyter_server_proxy: bool
+ useJupyterServerProxy: bool
whether the connection should be established using Jupyter Server Proxy.
If True, the baseURL needs to be adjusted accordingly.
Default = False
- use_jupyter_server_proxy_https: bool
- Access using wss, to Jupyter server proxy. There it will be decrypted and send as ws to socket
+ useJupyterServerProxyHttps: bool
+ whether the connection should be established using Jupyter Server Proxy
+ using wss. Use this if your notebook server is running on HTTPS.
+ Beware, communication behind the proxy will still be unencrypted if
+ your webserver was not started on HTTPS (using a SSL key and certificate).
Default = False
disableExternalPort: bool
- If the external port is set (parsed from the URL passed to autobahn's factory),
- there will be a check if the used port in the communication matches the externalPort.
- In case a proxy is used, this will terminate the connection, because that check is failed.
- Setting the variable back to None after the Object is created, disables this check.
+ Disables port checking during the WebSocket opening handshake.
+ Needed when using Jupyter Server Proxy to prevent a port mismatch error
+ since the notebook and the webserver do not run on the same port.
Default = False
protocol: pv_wslink.PVServerProtocol
a custom PVServerProtocol class which handles clients requests and run
@@ -112,20 +116,20 @@ class RemoteRenderer(DOMWidget):
# Placeholder to force rendering updates on change.
_update = Int(0).tag(sync=True)
- def __init__(self, pvserver_host=None, pvserver_port=11111, baseURL='localhost', viewID="-1", use_jupyter_server_proxy=False, use_jupyter_server_proxy_https=False, disableExternalPort=False, protocol=None, *args, **kwargs):
+ def __init__(self, pvserverHost=None, pvserverPort=11111, viewID="-1", baseURL='localhost', useJupyterServerProxy=False, useJupyterServerProxyHttps=False, disableExternalPort=False, protocol=None, *args, **kwargs):
super().__init__(*args, **kwargs)
self.baseURL = baseURL
self.viewID = viewID
- self.use_jupyter_server_proxy = use_jupyter_server_proxy
- self.use_jupyter_server_proxy_https = use_jupyter_server_proxy_https
+ self.useJupyterServerProxy = useJupyterServerProxy
+ self.useJupyterServerProxyHttps = useJupyterServerProxyHttps
self.disableExternalPort = disableExternalPort
- self.pvserver_host = pvserver_host
- self.pvserver_port = pvserver_port
+ self.pvserverHost = pvserverHost
+ self.pvserverPort = pvserverPort
self.protocol = protocol
- self.start_webserver(self.protocol, **kwargs)
+ self.start_webserver(**kwargs)
- def start_webserver(self, protocol=None, **kwargs):
+ def start_webserver(self, **kwargs):
"""Start a ParaViewWeb server with the given arguments."""
from paraview.web import pv_wslink
from paraview.web import protocols as pv_protocols
@@ -148,8 +152,7 @@ class RemoteRenderer(DOMWidget):
from paraview.simple import Connect as PVConnect
PVConnect(_CustomServer.pv_host, _CustomServer.pv_port)
- if protocol == None:
- protocol = _CustomServer
+ protocol = _CustomServer if self.protocol == None else self.protocol
# Create argument parser and add arguments (imitates command line)
parser = argparse.ArgumentParser(description="ParaView Web Server")
@@ -183,37 +186,35 @@ class RemoteRenderer(DOMWidget):
arg_list.append('-a')
arg_list.append(authKey)
args = parser.parse_args(arg_list)
- # print(args)
# Start server
if protocol == _CustomServer:
_CustomServer.authKey = args.authKey
- if self.pvserver_host is not None:
- _CustomServer.pv_host = self.pvserver_host
- _CustomServer.pv_port = self.pvserver_port
+ if self.pvserverHost is not None:
+ _CustomServer.pv_host = self.pvserverHost
+ _CustomServer.pv_port = self.pvserverPort
else:
protocol.authKey = args.authKey
self.protocol = server.start_webserver(options=args, disableExternalPort=self.disableExternalPort, protocol=protocol)
- # Set authKey and URL for the websocket connection
+ # Set authKey and URL for the WebSocket connection
self.authKey = args.authKey
self.port = args.port
self.sessionURL = '{wsProtocol}://{baseURL}{use_proxy}{port}/{ws_endpoint}'.format(
- wsProtocol='wss' if (args.sslKey and args.sslCert) or self.use_jupyter_server_proxy_https else 'ws',
- use_proxy='/proxy/' if self.use_jupyter_server_proxy else ':',
+ wsProtocol='wss' if (args.sslKey and args.sslCert) or self.useJupyterServerProxyHttps else 'ws',
+ use_proxy='/proxy/' if self.useJupyterServerProxy or self.useJupyterServerProxyHttps else ':',
baseURL=self.baseURL, port=args.port, ws_endpoint=args.ws
)
-
def update_render(self):
"""Explicit call for the renderer on the javascript side to render."""
self._update += 1
def get_webserver_port(self):
- """Get the port, that can be used to reach the websocket."""
+ """Get the port, that can be used to reach the WebSocket."""
return self.port
def get_authKey(self):
- """Get the key, used for authentification for the websocket connection."""
+ """Get the key, used for authentification for the WebSocket connection."""
return self.authKey
def webserver_arguments_help():
diff --git a/pvlink/server.py b/pvlink/server.py
index 44068bcd596281b1d0bed4a8ff59420aa2d083b9..65f841fbeca610fd76bed76ba24d312e6dcd1995 100644
--- a/pvlink/server.py
+++ b/pvlink/server.py
@@ -65,9 +65,14 @@ def start_webserver(options, protocol=wsl.ServerProtocol, disableLogging=False,
transport_factory.protocol = wsl.WslinkWebSocketServerProtocol
transport_factory.setServerProtocol(wslinkServer)
- # The used autobahn factory sets the external port after interpreting the url string.
- # In this case we do not need the externalPort, it is even causing problems, in case the port is proxied,
- # because then the communication request is denied, because autobahn detects a port mismatch
+ # If we pass a URL to the WebSocketServerFactory,
+ # the external port is automatically set to the port in the URL.
+ # Upon establishing a websocket connection, Autobahn then checks
+ # if the port in the HTTP Host header matches this external port.
+ # When using Jupyter Server Proxy, these two ports do not match since
+ # the notebook server runs on a different port than the webserver
+ # and the WebSocket opening handshake will fail.
+ # Setting the external port back to None disables port checking.
if disableExternalPort:
transport_factory.externalPort = None
diff --git a/pvlink/simplerenderer.py b/pvlink/simplerenderer.py
index a1b631b4cc8e3d0fec7412e839b3c8fff76cdcac..f2d86a9e42173730397c302b2af46f05aa4fcbf7 100644
--- a/pvlink/simplerenderer.py
+++ b/pvlink/simplerenderer.py
@@ -32,7 +32,8 @@ class SimpleRenderer(DOMWidget):
authentication key for clients to connect to the server
Default = "wslink-secret"
viewID: str
- viewID of the view to connect to (only relevant if multiple views exist on the server side)
+ viewID of the view to connect to
+ (only relevant if multiple views exist on the server side)
Default = "-1"
Examples