115 | 
118 |
119 | Test
116 | 117 |
118 |
118 | .*+)" $h;
12 | }
13 |
14 | map $http_host $parsed_server_port {
15 | default $server_port;
16 | "~(?P .*+)" $p;
17 | }
18 |
19 | upstream mapproxy_backend {
20 | QGIS_SERVER_HTTP_SERVERS
21 | }
22 |
23 | server {
24 | listen 83 default_server;
25 | listen [::]:83 default_server;
26 |
27 | # This is vital
28 | underscores_in_headers on;
29 |
30 | root QGIS_SERVER_DIR/htdocs;
31 |
32 | location / {
33 |
34 | # $http_host contains the original server name and port, such as: "localhost:8080"
35 | # QGIS Server behind a VM needs this parsed values in order to automatically
36 | # get the correct values for the online resource URIs
37 | # Pass headers to proxy
38 | proxy_set_header X_FORWARDED_HOST $parsed_server_name:$parsed_server_port;
39 |
40 | proxy_pass http://mapproxy_backend;
41 | }
42 |
43 | }
44 |
45 |
--------------------------------------------------------------------------------
/resources/nginx/qgis-server-fcgi:
--------------------------------------------------------------------------------
1 | # Default QGIS server configuration template
2 | # This is parsed by provisioning scripts to
3 | # create the final configuration file
4 |
5 | # Extract server name and port from HTTP_HOST, this
6 | # is needed because we are behind a VMs mapped port
7 |
8 | map $http_host $parsed_server_name {
9 | default $host;
10 | "~(?P .*+)" $h;
11 | }
12 |
13 | map $http_host $parsed_server_port {
14 | default $server_port;
15 | "~(?P .*+)" $p;
16 | }
17 |
18 | upstream qgis_mapserv_backend {
19 | QGIS_SERVER_SOCKETS
20 | }
21 |
22 | server {
23 | listen 80 default_server;
24 | listen [::]:80 default_server;
25 |
26 | # This is vital
27 | underscores_in_headers on;
28 |
29 | root QGIS_SERVER_DIR/htdocs;
30 |
31 | location / {
32 | # First attempt to serve request as file, then
33 | # as directory, then fall back to displaying a 404.
34 | try_files $uri $uri/ =404;
35 | }
36 |
37 | # project file set by env var
38 | # example: http://localhost:8082/project_base_name
39 | location ~ ^/project/([^/]+)/?(.*)$
40 | {
41 | set $qgis_project /qgis-server/projects/$1.qgs;
42 | rewrite ^/project/(.*)$ /cgi-bin/qgis_mapserv.fcgi last;
43 | }
44 |
45 | location /cgi-bin/ {
46 | # Disable gzip (it makes scripts feel slower since they have to complete
47 | # before getting gzipped)
48 | gzip off;
49 |
50 | # Fastcgi socket
51 | fastcgi_pass qgis_mapserv_backend;
52 |
53 | # $http_host contains the original server name and port, such as: "localhost:8080"
54 | # QGIS Server behind a VM needs this parsed values in order to automatically
55 | # get the correct values for the online resource URIs
56 | fastcgi_param SERVER_NAME $parsed_server_name;
57 | fastcgi_param SERVER_PORT $parsed_server_port;
58 |
59 | # Set project file from env var
60 | fastcgi_param QGIS_PROJECT_FILE $qgis_project;
61 |
62 | # Fastcgi parameters, include the standard ones
63 | # Note: this needs to be last or it will take precedence over the SERVER_NAME/PORT overridden above
64 | # See: https://www.digitalocean.com/community/tutorials/understanding-and-implementing-fastcgi-proxying-in-nginx
65 | include /etc/nginx/fastcgi_params;
66 |
67 | }
68 |
69 | }
70 |
--------------------------------------------------------------------------------
/resources/nginx/qgis-server-python:
--------------------------------------------------------------------------------
1 | # Default QGIS server configuration template for Python server
2 | # This is parsed by provisioning scripts to
3 | # create the final configuration file
4 |
5 | # Extract server name and port from HTTP_HOST, this
6 | # is needed because we are behind a VMs mapped port
7 |
8 | map $http_host $parsed_server_name {
9 | default $host;
10 | "~(?P .*+)" $h;
11 | }
12 |
13 | map $http_host $parsed_server_port {
14 | default $host;
15 | "~(?P .*+)" $p;
16 | }
17 |
18 | upstream qgis_mapserv_python_backend {
19 | QGIS_SERVER_HTTP_SERVERS
20 | }
21 |
22 | server {
23 | listen 82 default_server;
24 | listen [::]:82 default_server;
25 |
26 | # This is vital
27 | underscores_in_headers on;
28 |
29 | root QGIS_SERVER_DIR/htdocs;
30 |
31 | location / {
32 | # First attempt to serve request as file, then
33 | # as directory, then fall back to displaying a 404.
34 | try_files $uri $uri/ =404;
35 | }
36 |
37 |
38 |
39 | location /cgi-bin/ {
40 |
41 | # $http_host contains the original server name and port, such as: "localhost:8080"
42 | # QGIS Server behind a VM needs this parsed values in order to automatically
43 | # get the correct values for the online resource URIs
44 | # Pass headers to proxy
45 | proxy_set_header HOST $parsed_server_name;
46 | proxy_set_header PORT $parsed_server_port;
47 | proxy_set_header SERVER_NAME $parsed_server_name;
48 | proxy_set_header SERVER_PORT $parsed_server_port;
49 | proxy_pass http://qgis_mapserv_python_backend;
50 |
51 | }
52 |
53 | }
54 |
--------------------------------------------------------------------------------
/resources/qgis/wms-wfs-test-project.qgd:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/elpaso/qgis3-server-vagrant/e0b0bdbeb91abaae401291525494dc9e6abe3674/resources/qgis/wms-wfs-test-project.qgd
--------------------------------------------------------------------------------
/resources/systemd/mapproxy@.service:
--------------------------------------------------------------------------------
1 |
2 | # Listen on ports 810%i
3 | # Path: /etc/systemd/system/mapproxy@.service
4 | # systemctl start mapproxy@{1..4}.service
5 |
6 |
7 | [Unit]
8 | Description = Mapproxy backend (instance %i)
9 | Wants = network.target
10 | After = network.target
11 |
12 | [Service]
13 | Restart = always
14 | User = www-data
15 | Group = www-data
16 | WorkingDirectory = MAPPROXY_DIR
17 | ExecStart = MAPPROXY_DIR/bin/mapproxy-util serve-develop -b 0.0.0.0:810%i MAPPROXY_DIR/myconfig/mapproxy.yaml
18 |
19 | [Install]
20 | WantedBy = multi-user.target
--------------------------------------------------------------------------------
/resources/systemd/qgis-server-fcgi@.service:
--------------------------------------------------------------------------------
1 |
2 | # Path: /etc/systemd/system/qgis-server-fcgi@.service
3 | # systemctl start qgis-fcgi@{1..4}.service
4 | # Used by Nginx
5 |
6 | [Unit]
7 | Description = QGIS Server Tracker FastCGI backend (instance %i)
8 |
9 | [Service]
10 | User = www-data
11 | Group = www-data
12 | ExecStart = /usr/lib/cgi-bin/qgis_mapserv.fcgi
13 | StandardInput = socket
14 | #StandardOutput = null
15 | #StandardError = null
16 | StandardOutput=syslog
17 | StandardError=syslog
18 | SyslogIdentifier=qgis-server-fcgi
19 | WorkingDirectory=/tmp
20 |
21 | Restart = always
22 |
23 | # Environment
24 | Environment="QGIS_AUTH_DB_DIR_PATH=QGIS_SERVER_DIR/projects"
25 | Environment="QGIS_SERVER_LOG_FILE=QGIS_SERVER_DIR/logs/qgis-server-fcgi-nginx.log"
26 | # For stderr logging (goes to syslog)
27 | #Environment="QGIS_SERVER_LOG_FILE=''"
28 | #Environment="QGIS_SERVER_LOG_STDERR=1"
29 | Environment="QGIS_SERVER_LOG_LEVEL=0"
30 | Environment="QGIS_DEBUG=1"
31 | Environment="DISPLAY=:99"
32 | Environment="QGIS_PLUGINPATH=QGIS_SERVER_DIR/plugins"
33 | Environment="QGIS_OPTIONS_PATH=QGIS_SERVER_DIR"
34 | Environment="QGIS_CUSTOM_CONFIG_PATH=QGIS_SERVER_DIR"
35 |
36 | [Install]
37 | WantedBy = multi-user.target
--------------------------------------------------------------------------------
/resources/systemd/qgis-server-fcgi@.socket:
--------------------------------------------------------------------------------
1 |
2 | # Path: /etc/systemd/system/qgis-fcgi@.socket
3 | # systemctl enable qgis-fcgi@{1..4}.socket && systemctl start qgis-fcgi@{1..4}.socket
4 |
5 | [Unit]
6 | Description = QGIS Server FastCGI Socket (instance %i)
7 |
8 | [Socket]
9 | Accept = false
10 | SocketUser = www-data
11 | SocketGroup = www-data
12 | SocketMode = 0660
13 | ListenStream = /run/qgis_mapserv%i.sock
14 |
15 | [Install]
16 | WantedBy = sockets.target
--------------------------------------------------------------------------------
/resources/systemd/qgis-server-python@.service:
--------------------------------------------------------------------------------
1 |
2 | # Listen on ports 809%i
3 | # Path: /etc/systemd/systemQGIS_SERVER_DIR-python@.service
4 | # systemctl start qgis-server-python@{1..4}.service
5 |
6 |
7 | [Unit]
8 | Description = QGIS Server Tracker Python backend (instance %i)
9 |
10 | [Service]
11 | User = www-data
12 | Group = www-data
13 | ExecStart = QGIS_SERVER_DIR/qgis_wrapped_server_wsgi.py
14 | StandardInput = null
15 | #StandardOutput = null
16 | #StandardError = null
17 | StandardOutput=syslog
18 | StandardError=syslog
19 | SyslogIdentifier=qgis-server-python
20 | WorkingDirectory=/tmp
21 |
22 | Restart = always
23 |
24 | # Environment
25 | Environment=QGIS_SERVER_PORT=809%i
26 | Environment="QGIS_AUTH_DB_DIR_PATH=QGIS_SERVER_DIR/projects"
27 | Environment="QGIS_SERVER_LOG_FILE=QGIS_SERVER_DIR/logs/qgis-server-python.log"
28 | Environment="QGIS_SERVER_LOG_LEVEL=0"
29 | Environment="QGIS_DEBUG=1"
30 | # Temporary workaround for #18230
31 | Environment="QGIS_PREFIX_PATH=/usr"
32 | Environment="DISPLAY=:99"
33 | Environment="QGIS_PLUGINPATH=QGIS_SERVER_DIR/plugins"
34 | Environment="QGIS_OPTIONS_PATH=QGIS_SERVER_DIR"
35 | Environment="QGIS_CUSTOM_CONFIG_PATH=QGIS_SERVER_DIR"
36 |
37 | [Install]
38 | WantedBy = multi-user.target
39 |
--------------------------------------------------------------------------------
/resources/uwsgi/README.md:
--------------------------------------------------------------------------------
1 | Uwsgi configuration does not work and hangs forever.
2 |
3 | The python script is actually used from nging proxy started with systemd
4 |
--------------------------------------------------------------------------------
/resources/uwsgi/qgis-server.ini:
--------------------------------------------------------------------------------
1 | # NOT USED: SEE README.md
2 |
3 | [uwsgi]
4 |
5 | socket = /run/qgis_mapserv_wsgi.sock
6 |
7 | wsgi-file = QGIS_SERVER_DIR/qgis_wrapped_server_wsgi.py
8 |
9 | processes = 4
10 | threads = 1
11 |
12 | uid = www-data
13 | gid = www-data
14 |
15 | chdir = QGIS_SERVER_DIR
16 |
17 | master = true
18 | chmod-socket = 777
19 | vacuum = true
20 |
21 | logto = QGIS_SERVER_DIR/logs/qgis-nginx-wsgi-000.log
22 |
23 | env = QGIS_AUTH_DB_DIR_PATH=QGIS_SERVER_DIR/projects
24 | env = QGIS_SERVER_LOG_FILE=QGIS_SERVER_DIR/logs/qgis-nginx-wsgi-000.log
25 | env = QGIS_SERVER_LOG_LEVEL=0
26 | env = QGIS_DEBUG=1
27 | # Temporary workaround for #18230
28 | env = QGIS_PREFIX_PATH=/usr
29 | env = DISPLAY=:99
30 | env = QGIS_PLUGINPATH=QGIS_SERVER_DIR/plugins
31 | env = QGIS_OPTIONS_PATH=QGIS_SERVER_DIR
32 | env = QGIS_CUSTOM_CONFIG_PATH=QGIS_SERVER_DIR
33 |
--------------------------------------------------------------------------------
/resources/uwsgi/qgis_wrapped_server.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | """
3 | QGIS Server HTTP wrapper
4 |
5 | This script launches a QGIS Server listening on port 8081 or on the port
6 | specified on the environment variable QGIS_SERVER_PORT.
7 | QGIS_SERVER_HOST (defaults to 127.0.0.1)
8 |
9 | A XYZ map service is also available for multithreading testing:
10 |
11 | ?MAP=/path/to/projects.qgs&SERVICE=XYZ&X=1&Y=0&Z=1&LAYERS=world
12 |
13 | Note that multi threading in QGIS server is not officially supported and
14 | it is not supposed to work in any case
15 |
16 | Set MULTITHREADING environment variable to 1 to activate.
17 |
18 |
19 | For testing purposes, HTTP Basic can be enabled by setting the following
20 | environment variables:
21 |
22 | * QGIS_SERVER_HTTP_BASIC_AUTH (default not set, set to anything to enable)
23 | * QGIS_SERVER_USERNAME (default ="username")
24 | * QGIS_SERVER_PASSWORD (default ="password")
25 |
26 | PKI authentication with HTTPS can be enabled with:
27 |
28 | * QGIS_SERVER_PKI_CERTIFICATE (server certificate)
29 | * QGIS_SERVER_PKI_KEY (server private key)
30 | * QGIS_SERVER_PKI_AUTHORITY (root CA)
31 | * QGIS_SERVER_PKI_USERNAME (valid username)
32 |
33 | Sample run:
34 |
35 | QGIS_SERVER_PKI_USERNAME=Gerardus QGIS_SERVER_PORT=47547 QGIS_SERVER_HOST=localhost \
36 | QGIS_SERVER_PKI_KEY=/home/$USER/dev/QGIS/tests/testdata/auth_system/certs_keys/localhost_ssl_key.pem \
37 | QGIS_SERVER_PKI_CERTIFICATE=/home/$USER/dev/QGIS/tests/testdata/auth_system/certs_keys/localhost_ssl_cert.pem \
38 | QGIS_SERVER_PKI_AUTHORITY=/home/$USER/dev/QGIS/tests/testdata/auth_system/certs_keys/chains_subissuer-issuer-root_issuer2-root2.pem \
39 | python3 /home/$USER/dev/QGIS/tests/src/python/qgis_wrapped_server.py
40 |
41 | .. note:: This program is free software; you can redistribute it and/or modify
42 | it under the terms of the GNU General Public License as published by
43 | the Free Software Foundation; either version 2 of the License, or
44 | (at your option) any later version.
45 | """
46 |
47 | __author__ = 'Alessandro Pasotti'
48 | __date__ = '05/15/2016'
49 | __copyright__ = 'Copyright 2016, The QGIS Project'
50 | # This will get replaced with a git SHA1 when you do a git archive
51 | __revision__ = '$Format:%H$'
52 |
53 |
54 | import os
55 |
56 | # Needed on Qt 5 so that the serialization of XML is consistent among all executions
57 | os.environ['QT_HASH_SEED'] = '1'
58 |
59 | import sys
60 | import signal
61 | import ssl
62 | import math
63 | import urllib.parse
64 | import importlib
65 | from http.server import BaseHTTPRequestHandler, HTTPServer
66 | from socketserver import ThreadingMixIn
67 | import threading
68 |
69 | from qgis.core import QgsApplication, QgsCoordinateTransform, QgsCoordinateReferenceSystem, QgsMessageLog
70 | from qgis.server import QgsServer, QgsServerRequest, QgsBufferServerRequest, QgsBufferServerResponse, QgsServerFilter
71 |
72 | QGIS_SERVER_PORT = int(os.environ.get('QGIS_SERVER_PORT', '8081'))
73 | QGIS_SERVER_HOST = os.environ.get('QGIS_SERVER_HOST', '127.0.0.1')
74 | # PKI authentication
75 | QGIS_SERVER_PKI_CERTIFICATE = os.environ.get('QGIS_SERVER_PKI_CERTIFICATE')
76 | QGIS_SERVER_PKI_KEY = os.environ.get('QGIS_SERVER_PKI_KEY')
77 | QGIS_SERVER_PKI_AUTHORITY = os.environ.get('QGIS_SERVER_PKI_AUTHORITY')
78 | QGIS_SERVER_PKI_USERNAME = os.environ.get('QGIS_SERVER_PKI_USERNAME')
79 |
80 | # Check if PKI - https is enabled
81 | https = (QGIS_SERVER_PKI_CERTIFICATE is not None and
82 | os.path.isfile(QGIS_SERVER_PKI_CERTIFICATE) and
83 | QGIS_SERVER_PKI_KEY is not None and
84 | os.path.isfile(QGIS_SERVER_PKI_KEY) and
85 | QGIS_SERVER_PKI_AUTHORITY is not None and
86 | os.path.isfile(QGIS_SERVER_PKI_AUTHORITY) and
87 | QGIS_SERVER_PKI_USERNAME)
88 |
89 |
90 | qgs_app = QgsApplication([], False)
91 | qgs_server = QgsServer()
92 |
93 |
94 |
95 | # Load plugins
96 | if os.environ.get('QGIS_PLUGINPATH', False):
97 | plugindir = os.environ.get('QGIS_PLUGINPATH')
98 | sys.path.append(plugindir)
99 | # Magic mistery: without this, virtual QgsServerFilter instances are not wrapped
100 | iface = qgs_server.serverInterface()
101 | try:
102 | for modulename in [(a, b, c) for a, b, c in os.walk(plugindir)][0][1]:
103 | try:
104 | module = importlib.import_module(modulename)
105 | getattr(module, 'serverClassFactory')(iface)
106 | QgsMessageLog.logMessage('Python plugin %s loaded!' % modulename)
107 | except:
108 | QgsMessageLog.logMessage('Could not load Python plugin %s!' % modulename)
109 | except:
110 | QgsMessageLog.logMessage('No plugins found in %s!' % plugindir)
111 |
112 |
113 |
114 | class Handler(BaseHTTPRequestHandler):
115 |
116 | def do_GET(self, post_body=None):
117 | # CGI vars:
118 | headers = {}
119 | for k, v in self.headers.items():
120 | headers['%s%s' % ('HTTP_' if not k.startswith('HTTP') else '', k.replace(' ', '-').replace('-', '_').replace(' ', '-').upper())] = v
121 | if not self.path.startswith('http'):
122 | self.path = "%s://%s:%s%s" % ('https' if https else 'http', QGIS_SERVER_HOST, self.server.server_port, self.path)
123 | request = QgsBufferServerRequest(self.path, (QgsServerRequest.PostMethod if post_body is not None else QgsServerRequest.GetMethod), headers, post_body)
124 | response = QgsBufferServerResponse()
125 | qgs_server.handleRequest(request, response)
126 |
127 | headers_dict = response.headers()
128 | try:
129 | self.send_response(int(headers_dict['Status'].split(' ')[0]))
130 | except:
131 | self.send_response(200)
132 | for k, v in headers_dict.items():
133 | self.send_header(k, v)
134 | self.end_headers()
135 | self.wfile.write(response.body())
136 | return
137 |
138 | def do_POST(self):
139 | content_len = int(self.headers.get('content-length', 0))
140 | post_body = self.rfile.read(content_len)
141 | return self.do_GET(post_body)
142 |
143 |
144 | class ThreadedHTTPServer(ThreadingMixIn, HTTPServer):
145 | """Handle requests in a separate thread."""
146 | pass
147 |
148 |
149 | if __name__ == '__main__':
150 | if os.environ.get('MULTITHREADING') == '1':
151 | server = ThreadedHTTPServer((QGIS_SERVER_HOST, QGIS_SERVER_PORT), Handler)
152 | else:
153 | server = HTTPServer((QGIS_SERVER_HOST, QGIS_SERVER_PORT), Handler)
154 | if https:
155 | server.socket = ssl.wrap_socket(server.socket,
156 | certfile=QGIS_SERVER_PKI_CERTIFICATE,
157 | keyfile=QGIS_SERVER_PKI_KEY,
158 | ca_certs=QGIS_SERVER_PKI_AUTHORITY,
159 | cert_reqs=ssl.CERT_REQUIRED,
160 | server_side=True,
161 | ssl_version=ssl.PROTOCOL_TLSv1)
162 | print('Starting server on %s://%s:%s, use HTTP Basic authentication: qgis/qgis Place your HTML content here! or browse one of the default endpoints: %s "%s" %s "%s"QGIS Server Demo
14 |
17 |
18 |
47 |
19 |
23 |
24 |
25 | Server
20 | Port
21 | Mapped to
22 |
26 |
30 | Nginx FastCGI
27 | 80
28 | 8080
29 |
31 |
35 | Apache (Fast)CGI
32 | 81
33 | 8081
34 |
36 |
40 | Nginx Python
37 | 82
38 | 8082
39 |
41 |
45 |
46 | Nginx mapproxy
42 | 83
43 | 8083
44 |
50 |
67 |
68 |
69 |
--------------------------------------------------------------------------------
/resources/web/plugins/ServerSimpleBrowser/README.rst:
--------------------------------------------------------------------------------
1 | Simple Browser Python plugin for QGIS Server
2 | ============================================
3 |
4 | This plugin adds a stylesheet to `GetProjectsettings` `WMS` requests, generating
5 | an HTML page with the project's layer tree and a link to a OpenLayers map
6 | preview of the layers.
7 |
8 | .. image:: assets/toctree.png
9 |
10 |
11 | The layer preview is generated by adding an new `application/openlayers` `FORMAT` to `GetMap`
12 | requests.
13 |
14 | .. image:: assets/preview.png
15 |
16 |
17 | For more informations on how to use Python plugins for QGIS Server, please refer
18 | to a series of posts on our company website:
19 |
20 | http://www.itopen.it/category/gis/qgis/qgis-server/
21 |
22 |
--------------------------------------------------------------------------------
/resources/web/plugins/ServerSimpleBrowser/ServerSimpleBrowser.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 |
3 | """
4 | ***************************************************************************
5 | ServerSimpleBrowseer.py
6 | ---------------------
7 | Date : August 2014
8 | Copyright : (C) 2014-2015 by Alessandro Pasotti
9 | Email : apasotti at gmail dot com
10 | ***************************************************************************
11 | * *
12 | * This program is free software; you can redistribute it and/or modify *
13 | * it under the terms of the GNU General Public License as published by *
14 | * the Free Software Foundation; either version 2 of the License, or *
15 | * (at your option) any later version. *
16 | * *
17 | ***************************************************************************
18 | """
19 |
20 | __author__ = 'Alessandro Pasotti'
21 | __date__ = 'March 2016'
22 | __copyright__ = '(C) 2016, Alessandro Pasotti - ItOpen'
23 |
24 | import sys
25 | import os
26 | import codecs
27 | import re
28 |
29 | # Import the PyQt and QGIS libraries
30 | from qgis.PyQt.QtCore import *
31 | from qgis.PyQt.QtGui import *
32 | from qgis.core import *
33 | from qgis.server import *
34 |
35 |
36 | class ServerSimpleFilter(QgsServerFilter):
37 |
38 | def get_url(self, request, params):
39 | url = 'http://' if not self.serverInterface().getEnv("HTTPS") == 'on' else 'https://'
40 |
41 | # First check for standard header
42 | http_host = self.serverInterface().requestHandler().requestHeader("Host")
43 | if http_host:
44 | url += http_host.strip()
45 | else:
46 | server_name = self.serverInterface().getEnv("SERVER_NAME")
47 | if not server_name:
48 | server_name = self.serverInterface().requestHandler().requestHeader("HTTP_HOST")
49 | server_port = self.serverInterface().getEnv("SERVER_PORT")
50 | if not server_port:
51 | server_port = self.serverInterface().requestHandler().requestHeader("HTTP_PORT")
52 | url += server_name
53 | url += ':' + server_port
54 |
55 | script_name = self.serverInterface().getEnv("SCRIPT_NAME")
56 | if not script_name:
57 | script_name = self.serverInterface().requestHandler().requestHeader("HTTP_PATH_INFO")
58 |
59 | url += script_name
60 | url += '?MAP=' + params.get('MAP', '')
61 | return url
62 |
63 |
64 | def requestReady(self):
65 | request = self.serverInterface().requestHandler()
66 | params = request.parameterMap( )
67 | if params.get('SERVICE', '').lower() == 'wms' \
68 | and params.get('REQUEST', '').lower() == 'getmap' \
69 | and params.get('FORMAT', '').lower() == 'application/openlayers':
70 | QgsMessageLog.logMessage("OpenLayersFilter.requestReady FORMAT application/openlayers")
71 | request.setParameter('SERVICE', 'OPENLAYERS')
72 |
73 |
74 | def responseComplete(self):
75 |
76 | # TODO: error checking
77 | request = self.serverInterface().requestHandler()
78 | params = request.parameterMap( )
79 |
80 |
81 | if params.get('SERVICE', '').lower() == 'openlayers':
82 | request.clear()
83 | request.setResponseHeader('Content-type', 'text/html; charset=utf-8')
84 | minx, miny, maxx, maxy = params.get('BBOX', '0,0,0,0').split(',')
85 | url = self.get_url(request, params)
86 | QgsMessageLog.logMessage("OpenLayersFilter.responseComplete URL %s" % url, 'plugin')
87 | f = open(os.path.join(os.path.dirname(__file__), 'assets' , 'map_template.html'))
88 | body = ''.join(f.readlines())
89 | f.close()
90 | body = body % {
91 | 'extent' : params.get('BBOX', ''),
92 | 'url' : url,
93 | 'layers': params.get('LAYERS', ''),
94 | 'center': center,
95 | 'zoom': params.get('ZOOM', '12'),
96 | 'height': params.get('HEIGHT', 400),
97 | 'width': params.get('WIDTH', 600),
98 | 'projection' : params.get('CRS', 'EPSG:4326'),
99 | }
100 | request.setStatusCode(200)
101 | request.appendBody(body.encode('utf8'))
102 | QgsMessageLog.logMessage("OpenLayersFilter.responseComplete BODY %s" % body, 'plugin')
103 | return
104 |
105 |
106 | if params.get('SERVICE', '').lower() == 'wms' \
107 | and params.get('REQUEST', '').lower() == 'xsl':
108 | request.clear()
109 | request.setResponseHeader('Content-type', 'text/xml; charset=utf-8')
110 | f = open(os.path.dirname(__file__) + '/assets/' + 'getprojectsettings.xsl')
111 | body = ''.join(f.readlines())
112 | f.close()
113 | request.setStatusCode(200)
114 | request.appendBody(body.encode('utf8'))
115 | return
116 |
117 |
118 | if params.get('SERVICE', '').lower() == 'wms' \
119 | and params.get('REQUEST', '').lower() == 'getprojectsettings':
120 | # inject XSL code
121 | body = request.body()
122 | request.clearBody()
123 | url = self.get_url(request, params).encode('utf8')
124 | body = body.replace(b'', b'\n' % url)
125 | request.appendBody(body)
126 | return
127 |
128 |
129 | class ServerSimpleBrowser:
130 | """Plugin for QGIS server"""
131 |
132 | def __init__(self, serverIface):
133 | # Save reference to the QGIS server interface
134 | self.serverIface = serverIface
135 | try:
136 | self.serverIface.registerFilter(ServerSimpleFilter(serverIface), 1000)
137 | except Exception as e:
138 | QgsLogger.debug("ServerSimpleBrowser- Error loading filter %s", e)
139 |
140 |
141 |
142 | class SimpleBrowser:
143 | def __init__(self, iface):
144 | # Save reference to the QGIS interface
145 | self.iface = iface
146 | self.canvas = iface.mapCanvas()
147 |
148 |
149 | def initGui(self):
150 | # Create action that will start plugin
151 | self.action = QAction(QIcon(":/plugins/"), "About Server SimpleBrowser", self.iface.mainWindow())
152 | # Add toolbar button and menu item
153 | self.iface.addPluginToMenu("Server SimpleBrowser", self.action)
154 | # connect the action to the run method
155 | QObject.connect(self.action, SIGNAL("activated()"), self.about)
156 |
157 | def unload(self):
158 | # Remove the plugin menu item and icon
159 | self.iface.removePluginMenu("Server SimpleBrowser", self.action)
160 |
161 | # run
162 | def about(self):
163 | QMessageBox.information(self.iface.mainWindow(), QCoreApplication.translate('SimpleBrowser', "Server SimpleBrowser"), QCoreApplication.translate('SimpleBrowser', "Server SimpleBrowser is a simple browser plugin for QGIS Server, it does just nothing in QGIS Desktop. See: plugin's homepage"))
164 |
165 |
166 |
167 | if __name__ == "__main__":
168 | pass
169 |
--------------------------------------------------------------------------------
/resources/web/plugins/ServerSimpleBrowser/__init__.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | """
3 | This script initializes the plugin, making it known to QGIS.
4 | """
5 |
6 |
7 | def serverClassFactory(serverIface):
8 | from .ServerSimpleBrowser import ServerSimpleBrowser
9 | return ServerSimpleBrowser(serverIface)
10 |
11 | def classFactory(iface):
12 | from .ServerSimpleBrowser import SimpleBrowser
13 | return SimpleBrowser(iface)
14 |
15 |
--------------------------------------------------------------------------------
/resources/web/plugins/ServerSimpleBrowser/assets/getprojectsettings.xsl:
--------------------------------------------------------------------------------
1 |
2 |
74 |
106 |
107 |
108 |
109 |
110 |
75 |
105 |
76 |
99 |
104 |
77 |
78 | QGIS Server Explorer
79 |
80 |
82 |
98 |
83 |
84 |
97 |
85 |
89 |
90 |
91 | Name
86 | Title
87 |
88 |
124 |
128 | View
127 |
25 |
26 |
27 |
28 |
29 |
53 |
54 |
55 |
56 |
57 |
62 |
63 |
64 |
65 |
66 |
67 |
68 |
71 |
74 |
75 |
76 |
--------------------------------------------------------------------------------
/resources/web/plugins/customapi/customapi.py:
--------------------------------------------------------------------------------
1 |
2 | import json
3 | import os
4 |
5 | from qgis.PyQt.QtCore import QBuffer, QIODevice, QTextStream, QRegularExpression
6 | from qgis.server import (
7 | QgsServiceRegistry,
8 | QgsService,
9 | QgsServerFilter,
10 | QgsServerOgcApi,
11 | QgsServerQueryStringParameter,
12 | QgsServerOgcApiHandler,
13 | )
14 |
15 | from qgis.core import (
16 | QgsMessageLog,
17 | QgsJsonExporter,
18 | QgsCircle,
19 | QgsFeature,
20 | QgsPoint,
21 | QgsGeometry,
22 | )
23 |
24 |
25 | class CustomApiHandler(QgsServerOgcApiHandler):
26 |
27 | def __init__(self):
28 | super(CustomApiHandler, self).__init__()
29 | self.setContentTypes([QgsServerOgcApi.HTML, QgsServerOgcApi.JSON])
30 |
31 | def path(self):
32 | return QRegularExpression("/customapi")
33 |
34 | def operationId(self):
35 | return "CustomApiXYCircle"
36 |
37 | def summary(self):
38 | return "Creates a circle around a point"
39 |
40 | def description(self):
41 | return "Creates a circle around a point"
42 |
43 | def linkTitle(self):
44 | return "Custom Api XY Circle"
45 |
46 | def linkType(self):
47 | return QgsServerOgcApi.data
48 |
49 | def handleRequest(self, context):
50 | """Simple Circle"""
51 |
52 | values = self.values(context)
53 | x = values['x']
54 | y = values['y']
55 | r = values['r']
56 | f = QgsFeature()
57 | f.setAttributes([x, y, r])
58 | f.setGeometry(QgsCircle(QgsPoint(x, y), r).toCircularString())
59 | exporter = QgsJsonExporter()
60 | self.write(json.loads(exporter.exportFeature(f)), context)
61 |
62 | def templatePath(self, context):
63 | return os.path.join(os.path.dirname(__file__), 'circle.html')
64 |
65 | def parameters(self, context):
66 | return [QgsServerQueryStringParameter('x', True, QgsServerQueryStringParameter.Type.Double, 'X coordinate'),
67 | QgsServerQueryStringParameter(
68 | 'y', True, QgsServerQueryStringParameter.Type.Double, 'Y coordinate'),
69 | QgsServerQueryStringParameter('r', True, QgsServerQueryStringParameter.Type.Double, 'radius')]
70 |
71 |
72 | class CustomApi():
73 |
74 | def __init__(self, serverIface):
75 | api = QgsServerOgcApi(serverIface, '/customapi',
76 | 'custom api', 'a custom api', '1.1')
77 | handler = CustomApiHandler()
78 | api.registerHandler(handler)
79 | serverIface.serviceRegistry().registerApi(api)
80 |
--------------------------------------------------------------------------------
/resources/web/plugins/customapi/metadata.txt:
--------------------------------------------------------------------------------
1 | [general]
2 | name=QGIS Server Custom API Plugin
3 | qgisMinimumVersion=3.9
4 | description=QGIS Server Custom API Plugin
5 | version=version 1.0
6 | author=Alessandro Pasotti (ItOpen)
7 | email=elpaso@itopen.it
8 | ; if True it's a server plugin
9 | server=True
10 |
11 | changelog=
12 |
13 | about=Adds Custom API
14 |
--------------------------------------------------------------------------------
/resources/web/plugins/customservice/__init__.py:
--------------------------------------------------------------------------------
1 | # Custom service plugin example
2 |
3 | def serverClassFactory(serverIface):
4 | from . customservice import CustomService
5 | return CustomService(serverIface)
6 |
7 |
--------------------------------------------------------------------------------
/resources/web/plugins/customservice/customservice.py:
--------------------------------------------------------------------------------
1 |
2 | # coding=utf-8
3 | """" Simple SERVICE custom implementation
4 |
5 | http://localhost:8080/cgi-bin/qgis_mapserv.cgi?MAP=/qgis-server/projects/helloworld.qgs&SERVICE=CUSTOM
6 |
7 | .. note:: This program is free software; you can redistribute it and/or modify
8 | it under the terms of the GNU General Public License as published by
9 | the Free Software Foundation; either version 2 of the License, or
10 | (at your option) any later version.
11 |
12 | """
13 |
14 | __author__ = 'elpaso@itopen.it'
15 | __date__ = '2019-08-26'
16 | __copyright__ = 'Copyright 2019, ItOpen'
17 |
18 |
19 | from qgis.PyQt.QtCore import QBuffer, QIODevice, QTextStream
20 | from qgis.server import (QgsServiceRegistry,
21 | QgsService, QgsServerFilter)
22 | from qgis.core import QgsMessageLog
23 |
24 | class CustomServiceService(QgsService):
25 |
26 | def __init__(self):
27 | QgsService.__init__(self)
28 |
29 | def name(self):
30 | return "CUSTOM"
31 |
32 | def version(self):
33 | return "1.0.0"
34 |
35 | def allowMethod(method):
36 | return True
37 |
38 | def executeRequest(self, request, response, project):
39 | response.setStatusCode(200)
40 | QgsMessageLog.logMessage('Custom service executeRequest')
41 | response.write("Custom service executeRequest")
42 |
43 |
44 | class CustomService():
45 |
46 | def __init__(self, serverIface):
47 | self.serv = CustomServiceService()
48 | serverIface.serviceRegistry().registerService(CustomServiceService())
49 |
50 |
--------------------------------------------------------------------------------
/resources/web/plugins/customservice/metadata.txt:
--------------------------------------------------------------------------------
1 | [general]
2 | name=QGIS Server Custom Service Plugin
3 | qgisMinimumVersion=3.0
4 | description=QGIS Server Custom Service Plugin
5 | version=version 1.0
6 | author=Alessandro Pasotti (ItOpen)
7 | email=elpaso@itopen.it
8 | ; if True it's a server plugin
9 | server=True
10 |
11 | changelog=
12 |
13 | about=Adds Custom Service
14 |
--------------------------------------------------------------------------------
/resources/web/plugins/debug/__init__.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | """
3 | This script initializes the plugin, making it known to QGIS.
4 | """
5 |
6 |
7 | def serverClassFactory(serverIface):
8 | from . debug import Debug
9 | return Debug(serverIface)
10 |
--------------------------------------------------------------------------------
/resources/web/plugins/debug/debug.py:
--------------------------------------------------------------------------------
1 | # coding=utf-8
2 | """" Simple DEBUG SERVICE plugin
3 |
4 | http://localhost:8080/cgi-bin/qgis_mapserv.cgi?SERVICE=DEBUG
5 |
6 | .. note:: This program is free software; you can redistribute it and/or modify
7 | it under the terms of the GNU General Public License as published by
8 | the Free Software Foundation; either version 2 of the License, or
9 | (at your option) any later version.
10 |
11 | """
12 |
13 | __author__ = 'elpaso@itopen.it'
14 | __date__ = '2019-08-26'
15 | __copyright__ = 'Copyright 2019, ItOpen'
16 |
17 |
18 |
19 |
20 | import os
21 |
22 | from qgis.server import *
23 | from qgis.core import QgsMessageLog
24 |
25 |
26 | class DebugFilter(QgsServerFilter):
27 |
28 | def requestReady(self):
29 | handler = self.serverInterface().requestHandler()
30 | params = handler.parameterMap( )
31 | if 'DEBUG' in params:
32 | handler.setParameter('SERVICE', 'DEBUG')
33 |
34 | def responseComplete(self):
35 | handler = self.serverInterface().requestHandler()
36 | params = handler.parameterMap( )
37 | if params.get('SERVICE') != 'DEBUG':
38 | return
39 |
40 | headers_dict = handler.requestHeaders()
41 | handler.clear()
42 | handler.setResponseHeader('Status', '200 Ok')
43 | handler.appendBody(b'
30 |
31 |
32 |
49 |
50 |
51 |
52 | Params
')
44 | for k in params:
45 | handler.appendBody(('Headers
'.encode('utf8'))
48 | for k in headers_dict:
49 | handler.appendBody(('Authorization required
')
61 |
62 |
63 |
64 | class HTTPBasic:
65 |
66 | def __init__(self, serverIface):
67 | # Save reference to the QGIS server interface
68 | serverIface.registerFilter( HTTPBasicFilter(serverIface), 10 )
69 |
70 |
--------------------------------------------------------------------------------
/resources/web/plugins/httpbasic/metadata.txt:
--------------------------------------------------------------------------------
1 | ; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2 | ;
3 | ; WARNING: this is only a demo and it is not for use in production:
4 | ; username and password are shown in the clear to the user
5 | ;
6 | ; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
7 |
8 |
9 | [general]
10 | name=!!!! DEMO: ++ NOT FOR PRODUCTION ++ QGIS Server HTTP Basic Auth Plugin !!!!
11 | qgisMinimumVersion=2.8
12 | qgisMaximumVersion=3.99
13 | description=QGIS Server HTTP Basic Auth Plugin
14 | version=version 1.0
15 | author=Alessandro Pasotti (ItOpen)
16 | email=elpaso@itopen.it
17 | ; if True it's a server plugin
18 | server=True
19 |
20 | changelog=
21 |
22 | about=Adds HTTP Basic Auth to WFS POST requests
--------------------------------------------------------------------------------
/resources/web/plugins/loadcustomexpressions/__init__.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | """
3 | This script initializes the plugin, making it known to QGIS.
4 | """
5 |
6 |
7 | def serverClassFactory(serverIface):
8 | from . loadcustomexpressions import LoadCustomExpressions
9 | return LoadCustomExpressions(serverIface)
10 |
--------------------------------------------------------------------------------
/resources/web/plugins/loadcustomexpressions/loadcustomexpressions.py:
--------------------------------------------------------------------------------
1 | import os
2 |
3 | from qgis.server import *
4 |
5 | # ########## Load the custom expressions ##########
6 | from qgis.utils import qgsfunction
7 | from qgis.core import QgsExpression
8 | from random import uniform
9 |
10 | @qgsfunction(args='auto', group='QGIS Workshop')
11 | def custom_qgis_function(value1, value2, feature, parent):
12 | return round(uniform(value1, value2), 2)
13 |
14 |
15 | QgsExpression.registerFunction(custom_qgis_function)
16 | # ########## Done loading custom expressions ##########
17 |
18 |
19 | class LoadCustomExpressionsFilter(QgsServerFilter):
20 |
21 | def __init__(self, serverIface):
22 | super(LoadCustomExpressionsFilter, self).__init__(serverIface)
23 |
24 |
25 | class LoadCustomExpressions:
26 |
27 | def __init__(self, serverIface):
28 | # Save reference to the QGIS server interface
29 | serverIface.registerFilter(LoadCustomExpressionsFilter(serverIface), 100)
30 |
--------------------------------------------------------------------------------
/resources/web/plugins/loadcustomexpressions/metadata.txt:
--------------------------------------------------------------------------------
1 | [general]
2 | name=QGIS LoadCustomExpressions Plugin
3 | qgisMinimumVersion=2.99
4 | qgisMaximumVersion=3.99
5 | description=LoadCustomExpressions Plugin
6 | version=version 1.0
7 | author=Tudor Bărăscu (QTIBIA Engineering)
8 | email=tudor.barascu@qtibia.ro
9 | ; if True it's a server plugin
10 | server=True
11 |
12 | changelog=
13 |
14 | about=Adds custom expressions to be used on the server side
15 |
--------------------------------------------------------------------------------
/resources/web/plugins/xyz/__init__.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | """
3 | This script initializes the plugin, making it known to QGIS.
4 | """
5 |
6 |
7 | def serverClassFactory(serverIface):
8 | from . xyz import XYZ
9 | return XYZ(serverIface)
10 |
--------------------------------------------------------------------------------
/resources/web/plugins/xyz/metadata.txt:
--------------------------------------------------------------------------------
1 | [general]
2 | name=QGIS Server XYZPlugin
3 | qgisMinimumVersion=3.0
4 | description=QGIS Server XYZPlugin
5 | version=version 1.0
6 | author=Alessandro Pasotti (ItOpen)
7 | email=elpaso@itopen.it
8 | ; if True it's a server plugin
9 | server=True
10 |
11 | changelog=
12 |
13 | about=Adds XYZ
14 |
--------------------------------------------------------------------------------
/resources/web/plugins/xyz/xyz.py:
--------------------------------------------------------------------------------
1 | import os
2 | import math
3 | from qgis.server import *
4 | from qgis.core import QgsMessageLog
5 |
6 | def num2deg(xtile, ytile, zoom):
7 | """This returns the NW-corner of the square. Use the function with xtile+1 and/or ytile+1
8 | to get the other corners. With xtile+0.5 & ytile+0.5 it will return the center of the tile."""
9 | n = 2.0 ** zoom
10 | lon_deg = xtile / n * 360.0 - 180.0
11 | lat_rad = math.atan(math.sinh(math.pi * (1 - 2 * ytile / n)))
12 | lat_deg = math.degrees(lat_rad)
13 | return (lat_deg, lon_deg)
14 |
15 |
16 | class XYZFilter(QgsServerFilter):
17 | """XYZ server, example: ?MAP=/path/to/projects.qgs&SERVICE=XYZ&X=1&Y=0&Z=1&LAYERS=world"""
18 |
19 | def safeGetInt(self, handler, param_name):
20 | try:
21 | return int(handler.parameter(param_name))
22 | except ValueError:
23 | return 0
24 |
25 | def requestReady(self):
26 | QgsMessageLog.logMessage('XYZ requestReady called!')
27 | handler = self.serverInterface().requestHandler()
28 | if handler.parameter('SERVICE') == 'XYZ':
29 | x = self.safeGetInt(handler, 'X')
30 | y = self.safeGetInt(handler, 'Y')
31 | z = self.safeGetInt(handler, 'Z')
32 | # NW corner
33 | lat_deg, lon_deg = num2deg(x, y, z)
34 | # SE corner
35 | lat_deg2, lon_deg2 = num2deg(x + 1, y + 1, z)
36 | handler.setParameter('SERVICE', 'WMS')
37 | handler.setParameter('REQUEST', 'GetMap')
38 | handler.setParameter('VERSION', '1.3.0')
39 | handler.setParameter('SRS', 'EPSG:4326')
40 | handler.setParameter('HEIGHT', '256')
41 | handler.setParameter('WIDTH', '256')
42 | handler.setParameter('BBOX', "{},{},{},{}".format(lat_deg2, lon_deg, lat_deg, lon_deg2))
43 |
44 |
45 | class XYZ:
46 | def __init__(self, serverIface):
47 | serverIface.registerFilter( XYZFilter(serverIface), 100 )
48 |
49 |
--------------------------------------------------------------------------------
/resources/web/projects/.directory:
--------------------------------------------------------------------------------
1 | [Dolphin]
2 | HeaderColumnWidths=1839,144,198,149
3 | Timestamp=2016,4,11,14,42,2
4 | Version=3
5 | ViewMode=1
6 | VisibleRoles=Details_text,Details_size,Details_date,Details_owner,CustomizedDetails
7 |
--------------------------------------------------------------------------------
/resources/web/projects/Readme.txt:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/elpaso/qgis3-server-vagrant/e0b0bdbeb91abaae401291525494dc9e6abe3674/resources/web/projects/Readme.txt
--------------------------------------------------------------------------------
/resources/web/projects/bluemarble.tiff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/elpaso/qgis3-server-vagrant/e0b0bdbeb91abaae401291525494dc9e6abe3674/resources/web/projects/bluemarble.tiff
--------------------------------------------------------------------------------
/resources/web/projects/helloworld.qgd:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/elpaso/qgis3-server-vagrant/e0b0bdbeb91abaae401291525494dc9e6abe3674/resources/web/projects/helloworld.qgd
--------------------------------------------------------------------------------
/resources/web/projects/world.dbf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/elpaso/qgis3-server-vagrant/e0b0bdbeb91abaae401291525494dc9e6abe3674/resources/web/projects/world.dbf
--------------------------------------------------------------------------------
/resources/web/projects/world.prj:
--------------------------------------------------------------------------------
1 | GEOGCS["GCS_WGS_1984",DATUM["D_WGS_1984",SPHEROID["WGS_1984",6378137.0,298.257223563]],PRIMEM["Greenwich",0.0],UNIT["Degree",0.0174532925199433]]
--------------------------------------------------------------------------------
/resources/web/projects/world.qix:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/elpaso/qgis3-server-vagrant/e0b0bdbeb91abaae401291525494dc9e6abe3674/resources/web/projects/world.qix
--------------------------------------------------------------------------------
/resources/web/projects/world.shp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/elpaso/qgis3-server-vagrant/e0b0bdbeb91abaae401291525494dc9e6abe3674/resources/web/projects/world.shp
--------------------------------------------------------------------------------
/resources/web/projects/world.shx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/elpaso/qgis3-server-vagrant/e0b0bdbeb91abaae401291525494dc9e6abe3674/resources/web/projects/world.shx
--------------------------------------------------------------------------------
/resources/xvfb/xvfb.service:
--------------------------------------------------------------------------------
1 | [Unit]
2 | Description=X Virtual Frame Buffer Service
3 | After=network.target
4 |
5 | [Service]
6 | ExecStart=/usr/bin/Xvfb :99 -screen 0 1024x768x24
7 |
8 | [Install]
9 | WantedBy=multi-user.target
10 |
--------------------------------------------------------------------------------