QGIS Server Python Plugins

Alessandro Pasotti (a.pasotti@itopen.it)

QGIS Server

QGIS Server is an open source WMS 1.3 and WFS 1.0.0 and WCS implementation whith advanced cartographic features for thematic mapping.

Starting from version 1.8 QGIS Server has Python plugins support.

Python plugin Goals

• modify existing services by manipulating input and output
• extend QGIS server by adding new services
• create new services
• Lower the development barriers by using Python
• Optional GUI-based one-click install & deployment
• Fast prototyping of new services

Not goals

• Replace the existing professional solutions available for heavy duty webservices

Possible applications

• web clients configuration
• authentication/authorization
• new services (WPS etc.)
• new output formats
• customization of standard services (ex: GetFeatureInfo)

Standard flow without plugins

Observer hooks

Server plugins register one or more QgsServerFilters that "listen to signals". Plugin filters receive the request/response objects and they can manipulate them with the following methods:

• requestReady : triggered after the request object is created
• responseComplete : triggered after the main loop completes
• sendResponse : triggered before response byte stream is sent to the client

Observer flowchart

Observer details

• Get the request

  • create request handler

  • call plugins requestReady filters

  • if not exception raised

    • if SERVICE is WMS/WFS/WCS

      • create WMS/WFS/WCS server

        • call server’s executeRequest

          • if it's a streaming service

            • call sendResponse for each chunk of bytes

          • store the byte stream and content type in the request handler

    • call plugin responseComplete

  • call plugin sendResponse

  • request handler outputs the response

requestReady

This is called when the request is ready: incoming URL and query string have been parsed.

This is the point where you can manipulate the input and perform actions like:

• authentication/authorization
• redirects
• add/remove/modify input (ex: typenames)
• raise exceptions

sendResponse

This is called whenever output is sent to FCGI stdout (and from there, to the client).

SendResponse is the best place for direct manipulation of core service’s output and while responseComplete is typically also an option, sendResponse is the only viable option in case of streaming services.

responseComplete

This is called once when the response is ready to be sent to the client.

responseComplete is the ideal place to provide new services implementation (WPS or custom services) and to perform direct manipulation of the output coming from core services (for example to add a watermark upon a WMS image).

Plugin example (metadata)

A server plugin must set server metadata

metadata.txt:

server=True

Plugin example (__init__)

A server plugin initialisation is similar to a desktop plugin, in __init__.py

def serverClassFactory(serverIface):
    from SimpleServer import SimpleServer
    return SimpleServer(serverIface)

Plugin example (SimpleServer)

# Import server and core
from qgis.server import *
from qgis.core import *

class SimpleServer:
    def __init__(self, serverIface):
        serverIface.registerFilter( \
            SimpleHelloFilter(serverIface)
            , 100 )

Plugin example (SimpleHelloFilter)

class SimpleHelloFilter(QgsServerFilter):
    def requestReady(self):
        QgsMessageLog.logMessage("requestReady")

    def sendResponse(self):
        QgsMessageLog.logMessage("sendResponse")

    def responseComplete(self):
        QgsMessageLog.logMessage("responseComplete")

Plugin example (responseComplete)

def responseComplete(self):
    request = self.serverInterface().requestHandler()
    params = request.parameterMap()
    if params.get('SERVICE', '').upper() == 'SIMPLE':
        request.clearHeaders()
        request.setHeader('Content-type', 'text/plain')
        request.clearBody()
        request.appendBody('HelloServer!')

QgsServerInterface

This is the server equivalent of desktop's iface

• requestHandler()

  • parameterMap()
  • clearHeaders()
  • setHeader()
  • clearBody()
  • appendBody()

• getEnv()

• registerFilter()

To GUI or not to GUI?

A Server plugin can have (not must) a desktop interface to configure itself

One-click install and deployment

Example(s)

An example plugin with a few example filters is available:

https://github.com/elpaso/qgis-helloserver

Example query string:

http://localhost/cgi-bin/qgis_mapserv.fcgi?SERVICE=HELLO&REQUEST=SayHello

Restrictions

If the plugin has a Desktop interface it cannot usually access to user's QSettings, this means that plugins options have to be stored somewhere else in order to be accessible by the server side.

Links & docs

• API: http://www.itopen.it/qgis/serverplugins/api/
• Docs/Tutorials: http://www.itopen.it/qgis-server-python-plugins-tutorial/

Thanks

Thanks to

• Martin Dobias
• Marco Hugentobler