QGIS API Documentation 3.29.0-Master (19d7edcfed)
qgsserversettings.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsserversettings.cpp
3 ---------------------
4 begin : December 19, 2016
5 copyright : (C) 2016 by Paul Blottiere
6 email : paul dot blottiere at oslandia dot com
7
8***************************************************************************/
9
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#include "qgsserversettings.h"
20#include "qgsapplication.h"
21#include "qgsvariantutils.h"
22
23#include <QSettings>
24#include <QDir>
25
27{
28 load();
29}
30
31void QgsServerSettings::initSettings()
32{
33 mSettings.clear();
34
35 // options path
36 const Setting sOptPath = { QgsServerSettingsEnv::QGIS_OPTIONS_PATH,
38 QStringLiteral( "Override the default path for user configuration" ),
39 QString(),
40 QVariant::String,
41 QVariant( "" ),
42 QVariant()
43 };
44 mSettings[ sOptPath.envVar ] = sOptPath;
45
46 // parallel rendering
49 QStringLiteral( "Activate/Deactivate parallel rendering for WMS getMap request" ),
50 QStringLiteral( "/qgis/parallel_rendering" ),
51 QVariant::Bool,
52 QVariant( false ),
53 QVariant()
54 };
55 mSettings[ sParRend.envVar ] = sParRend;
56
57 // max threads
58 const Setting sMaxThreads = { QgsServerSettingsEnv::QGIS_SERVER_MAX_THREADS,
60 QStringLiteral( "Number of threads to use when parallel rendering is activated" ),
61 QStringLiteral( "/qgis/max_threads" ),
62 QVariant::Int,
63 QVariant( -1 ),
64 QVariant()
65 };
66 mSettings[ sMaxThreads.envVar ] = sMaxThreads;
67
68 // log level
69 const Setting sLogLevel = { QgsServerSettingsEnv::QGIS_SERVER_LOG_LEVEL,
71 QStringLiteral( "Log level" ),
72 QString(),
73 QVariant::Int,
74 QVariant::fromValue( Qgis::MessageLevel::NoLevel ),
75 QVariant()
76 };
77 mSettings[ sLogLevel.envVar ] = sLogLevel;
78
79 // log file
80 const Setting sLogFile = { QgsServerSettingsEnv::QGIS_SERVER_LOG_FILE,
82 QStringLiteral( "Log file" ),
83 QString(),
84 QVariant::String,
85 QVariant( "" ),
86 QVariant()
87 };
88 mSettings[ sLogFile.envVar ] = sLogFile;
89
90 // log to stderr
91 const Setting sLogStderr = { QgsServerSettingsEnv::QGIS_SERVER_LOG_STDERR,
93 QStringLiteral( "Activate/Deactivate logging to stderr" ),
94 QString(),
95 QVariant::Bool,
96 QVariant( false ),
97 QVariant()
98 };
99 mSettings[ sLogStderr.envVar ] = sLogStderr;
100
101 // project file
102 const Setting sProject = { QgsServerSettingsEnv::QGIS_PROJECT_FILE,
104 QStringLiteral( "QGIS project file" ),
105 QString(),
106 QVariant::String,
107 QVariant( "" ),
108 QVariant()
109 };
110 mSettings[ sProject.envVar ] = sProject;
111
112 // cache directory
113 const Setting sCacheDir = { QgsServerSettingsEnv::QGIS_SERVER_CACHE_DIRECTORY,
115 QStringLiteral( "Specify the cache directory" ),
116 QStringLiteral( "/cache/directory" ),
117 QVariant::String,
118 QVariant( QgsApplication::qgisSettingsDirPath() + "cache" ),
119 QVariant()
120 };
121 mSettings[ sCacheDir.envVar ] = sCacheDir;
122
123 // cache size
124 const Setting sCacheSize = { QgsServerSettingsEnv::QGIS_SERVER_CACHE_SIZE,
126 QStringLiteral( "Specify the cache size" ),
127 QStringLiteral( "/cache/size" ),
128 QVariant::LongLong,
129 QVariant( 256 * 1024 * 1024 ),
130 QVariant()
131 };
132 mSettings[ sCacheSize.envVar ] = sCacheSize;
133
134 // system locale override
135 const Setting sOverrideSystemLocale = { QgsServerSettingsEnv::QGIS_SERVER_OVERRIDE_SYSTEM_LOCALE,
137 QStringLiteral( "Override system locale" ),
138 QStringLiteral( "/locale/userLocale" ),
139 QVariant::String,
140 QVariant( "" ),
141 QVariant()
142 };
143 mSettings[ sOverrideSystemLocale.envVar ] = sOverrideSystemLocale;
144
145 // bad layers handling
146 const Setting sIgnoreBadLayers = { QgsServerSettingsEnv::QGIS_SERVER_IGNORE_BAD_LAYERS,
148 QStringLiteral( "Ignore bad layers" ),
149 QString(),
150 QVariant::Bool,
151 QVariant( false ),
152 QVariant()
153 };
154 mSettings[ sIgnoreBadLayers.envVar ] = sIgnoreBadLayers;
155
156 // trust layer metadata
157 const Setting sTrustLayerMetadata = { QgsServerSettingsEnv::QGIS_SERVER_TRUST_LAYER_METADATA,
159 QStringLiteral( "Trust layer metadata" ),
160 QString(),
161 QVariant::Bool,
162 QVariant( false ),
163 QVariant()
164 };
165 mSettings[ sTrustLayerMetadata.envVar ] = sTrustLayerMetadata;
166
167
168 // force to open layers in read-only mode
169 const Setting sForceReadOnlyLayers = { QgsServerSettingsEnv::QGIS_SERVER_FORCE_READONLY_LAYERS,
171 QStringLiteral( "Force to open layers in read-only mode" ),
172 QString(),
173 QVariant::Bool,
174 QVariant( false ),
175 QVariant()
176 };
177 mSettings[ sForceReadOnlyLayers.envVar ] = sForceReadOnlyLayers;
178
179 // don't load layouts
180 const Setting sDontLoadLayouts = { QgsServerSettingsEnv::QGIS_SERVER_DISABLE_GETPRINT,
182 QStringLiteral( "Don't load layouts" ),
183 QString(),
184 QVariant::Bool,
185 QVariant( false ),
186 QVariant()
187 };
188 mSettings[ sDontLoadLayouts.envVar ] = sDontLoadLayouts;
189
190 // show group separator
191 const Setting sShowGroupSeparator = { QgsServerSettingsEnv::QGIS_SERVER_SHOW_GROUP_SEPARATOR,
193 QStringLiteral( "Show group (thousands) separator" ),
194 QStringLiteral( "/locale/showGroupSeparator" ),
195 QVariant::String,
196 QVariant( false ),
197 QVariant()
198 };
199 mSettings[ sShowGroupSeparator.envVar ] = sShowGroupSeparator;
200
201 // max height
202 const Setting sMaxHeight = { QgsServerSettingsEnv::QGIS_SERVER_WMS_MAX_HEIGHT,
204 QStringLiteral( "Maximum height for a WMS request. The lower one of this and the project configuration is used." ),
205 QStringLiteral( "/qgis/max_wms_height" ),
206 QVariant::LongLong,
207 QVariant( -1 ),
208 QVariant()
209 };
210 mSettings[ sMaxHeight.envVar ] = sMaxHeight;
211
212 // max width
213 const Setting sMaxWidth = { QgsServerSettingsEnv::QGIS_SERVER_WMS_MAX_WIDTH,
215 QStringLiteral( "Maximum width for a WMS request. The most conservative between this and the project one is used" ),
216 QStringLiteral( "/qgis/max_wms_width" ),
217 QVariant::LongLong,
218 QVariant( -1 ),
219 QVariant()
220 };
221 mSettings[ sMaxWidth.envVar ] = sMaxWidth;
222
223 // API templates and static override directory
224 const Setting sApiResourcesDirectory = { QgsServerSettingsEnv::QGIS_SERVER_API_RESOURCES_DIRECTORY,
226 QStringLiteral( "Base directory where HTML templates and static assets (e.g. images, js and css files) are searched for" ),
227 QStringLiteral( "/qgis/server_api_resources_directory" ),
228 QVariant::String,
229 QDir( QgsApplication::pkgDataPath() ).absoluteFilePath( QStringLiteral( "resources/server/api" ) ),
230 QString()
231 };
232
233 mSettings[ sApiResourcesDirectory.envVar ] = sApiResourcesDirectory;
234
235 // API WFS3 max limit
236 const Setting sApiWfs3MaxLimit = { QgsServerSettingsEnv::QGIS_SERVER_API_WFS3_MAX_LIMIT,
238 QStringLiteral( "Maximum value for \"limit\" in a features request, defaults to 10000" ),
239 QStringLiteral( "/qgis/server_api_wfs3_max_limit" ),
240 QVariant::LongLong,
241 QVariant( 10000 ),
242 QVariant()
243 };
244
245 mSettings[ sApiWfs3MaxLimit.envVar ] = sApiWfs3MaxLimit;
246
247 // projects directory for landing page service
248 const Setting sProjectsDirectories = { QgsServerSettingsEnv::QGIS_SERVER_LANDING_PAGE_PROJECTS_DIRECTORIES,
250 QStringLiteral( "Directories used by the landing page service to find .qgs and .qgz projects" ),
251 QStringLiteral( "/qgis/server_projects_directories" ),
252 QVariant::String,
253 QVariant( "" ),
254 QVariant()
255 };
256
257 mSettings[ sProjectsDirectories.envVar ] = sProjectsDirectories;
258
259 // postgresql connection string for landing page service
260 const Setting sProjectsPgConnections = { QgsServerSettingsEnv::QGIS_SERVER_LANDING_PAGE_PROJECTS_PG_CONNECTIONS,
262 QStringLiteral( "PostgreSQL connection strings used by the landing page service to find projects" ),
263 QStringLiteral( "/qgis/server_projects_pg_connections" ),
264 QVariant::String,
265 QVariant( "" ),
266 QVariant()
267 };
268
269 mSettings[ sProjectsPgConnections.envVar ] = sProjectsPgConnections;
270
271 // landing page base URL prefix
272 const Setting sLandingPageBaseUrlPrefix = { QgsServerSettingsEnv::QGIS_SERVER_LANDING_PAGE_PREFIX,
274 QStringLiteral( "Landing page base URL path prefix" ),
275 QStringLiteral( "/qgis/server_landing_page_base_url_prefix" ),
276 QVariant::String,
277 QVariant( "" ),
278 QVariant()
279 };
280
281 mSettings[ sLandingPageBaseUrlPrefix.envVar ] = sLandingPageBaseUrlPrefix;
282
283 // log profile
284 const Setting sLogProfile = { QgsServerSettingsEnv::QGIS_SERVER_LOG_PROFILE,
286 QStringLiteral( "Add detailed profile information to the logs, only effective when QGIS_SERVER_LOG_LEVEL=0" ),
287 QStringLiteral( "/qgis/server_log_profile" ),
288 QVariant::Bool,
289 QVariant( false ),
290 QVariant()
291 };
292
293 mSettings[ sLogProfile.envVar ] = sLogProfile;
294
295 // the default service URL.
296 const Setting sServiceUrl = { QgsServerSettingsEnv::QGIS_SERVER_SERVICE_URL,
298 QStringLiteral( "The default service URL" ),
299 QStringLiteral( "/qgis/server_service_url" ),
300 QVariant::String,
301 QVariant( "" ),
302 QVariant()
303 };
304 mSettings[ sServiceUrl.envVar ] = sServiceUrl;
305
306 // the default WMS service URL.
307 const Setting sWmsServiceUrl = { QgsServerSettingsEnv::QGIS_SERVER_WMS_SERVICE_URL,
309 QStringLiteral( "The default WMS service URL" ),
310 QStringLiteral( "/qgis/server_wms_service_url" ),
311 QVariant::String,
312 QVariant( "" ),
313 QVariant()
314 };
315 mSettings[ sServiceUrl.envVar ] = sWmsServiceUrl;
316
317 // the default WFS service URL.
318 const Setting sWfsServiceUrl = { QgsServerSettingsEnv::QGIS_SERVER_WFS_SERVICE_URL,
320 QStringLiteral( "The default WFS service URL" ),
321 QStringLiteral( "/qgis/server_wfs_service_url" ),
322 QVariant::String,
323 QVariant( "" ),
324 QVariant()
325 };
326 mSettings[ sServiceUrl.envVar ] = sWfsServiceUrl;
327
328 // the default WCS service URL.
329 const Setting sWcsServiceUrl = { QgsServerSettingsEnv::QGIS_SERVER_WCS_SERVICE_URL,
331 QStringLiteral( "The default WcS service URL" ),
332 QStringLiteral( "/qgis/server_wcs_service_url" ),
333 QVariant::String,
334 QVariant( "" ),
335 QVariant()
336 };
337 mSettings[ sServiceUrl.envVar ] = sWfsServiceUrl;
338
339 // the default WMTS service URL.
340 const Setting sWmtsServiceUrl = { QgsServerSettingsEnv::QGIS_SERVER_WMTS_SERVICE_URL,
342 QStringLiteral( "The default WMTS service URL" ),
343 QStringLiteral( "/qgis/server_wmts_service_url" ),
344 QVariant::String,
345 QVariant( "" ),
346 QVariant()
347 };
348 mSettings[ sServiceUrl.envVar ] = sWmtsServiceUrl;
349
350 // the default config cache check interval
351 const Setting sConfigCacheCheckInterval = { QgsServerSettingsEnv::QGIS_SERVER_PROJECT_CACHE_CHECK_INTERVAL,
353 QStringLiteral( "The default project cache check interval" ),
354 QStringLiteral( "/qgis/server_project_cache_check_interval" ),
355 QVariant::Int,
356 QVariant( 0 ),
357 QVariant()
358 };
359 mSettings[ sConfigCacheCheckInterval.envVar ] = sConfigCacheCheckInterval;
360
361 // the default config cache strategy
362 const Setting sProjectCacheStrategy = { QgsServerSettingsEnv::QGIS_SERVER_PROJECT_CACHE_STRATEGY,
364 QStringLiteral( "Project's cache strategy. Possible values are 'off','filesystem' or 'periodic'" ),
365 QStringLiteral( "/qgis/server_project_cache_strategy" ),
366 QVariant::String,
367 QVariant( "" ),
368 QVariant()
369 };
370 mSettings[ sProjectCacheStrategy.envVar ] = sProjectCacheStrategy;
371
372 const Setting sAllowedExtraSqlTokens = { QgsServerSettingsEnv::QGIS_SERVER_ALLOWED_EXTRA_SQL_TOKENS,
374 QStringLiteral( "List of comma separated SQL tokens to be added to the list of allowed tokens that the services accepts when filtering features" ),
375 QStringLiteral( "/qgis/server_allowed_extra_sql_tokens" ),
376 QVariant::String,
377 QVariant( "" ),
378 QVariant()
379 };
380 mSettings[ sAllowedExtraSqlTokens.envVar ] = sAllowedExtraSqlTokens;
381
382 const Setting sApplicationName = { QgsServerSettingsEnv::QGIS_SERVER_APPLICATION_NAME,
384 QStringLiteral( "The QGIS Server application name" ),
385 QStringLiteral( "/qgis/application_full_name" ),
386 QVariant::String,
388 QVariant()
389 };
390 mSettings[ sApplicationName.envVar ] = sApplicationName;
391
392}
393
395{
396 // init settings each time to take into account QgsApplication and
397 // QCoreApplication configuration for some default values
398 initSettings();
399
400 // store environment variables
401 QMap<QgsServerSettingsEnv::EnvVar, QString> env = getEnv();
402
403 // load QSettings if QGIS_OPTIONS_PATH is defined
404 loadQSettings( env[ QgsServerSettingsEnv::QGIS_OPTIONS_PATH ] );
405
406 // prioritize values: 'env var' -> 'ini file' -> 'default value'
407 prioritize( env );
408}
409
410bool QgsServerSettings::load( const QString &envVarName )
411{
412 bool rc( false );
413 const QMetaEnum metaEnum( QMetaEnum::fromType<QgsServerSettingsEnv::EnvVar>() );
414 const int value = metaEnum.keyToValue( envVarName.toStdString().c_str() );
415
416 if ( value >= 0 )
417 {
418 const QString envValue( getenv( envVarName.toStdString().c_str() ) );
419 prioritize( QMap<QgsServerSettingsEnv::EnvVar, QString> { {( QgsServerSettingsEnv::EnvVar ) value, envValue } } );
420 rc = true;
421 }
422
423 return rc;
424}
425
426QMap<QgsServerSettingsEnv::EnvVar, QString> QgsServerSettings::getEnv() const
427{
428 QMap<QgsServerSettingsEnv::EnvVar, QString> env;
429
430 const QMetaEnum metaEnum( QMetaEnum::fromType<QgsServerSettingsEnv::EnvVar>() );
431 for ( int i = 0; i < metaEnum.keyCount(); i++ )
432 {
433 env[( QgsServerSettingsEnv::EnvVar ) metaEnum.value( i )] = getenv( metaEnum.key( i ) );
434 }
435
436 return env;
437}
438
439QVariant QgsServerSettings::value( QgsServerSettingsEnv::EnvVar envVar, bool actual ) const
440{
441 if ( actual )
442 {
443 const QString envValue( getenv( name( envVar ).toStdString().c_str() ) );
444
445 if ( ! envValue.isEmpty() )
446 return envValue;
447 }
448
449 if ( mSettings[ envVar ].src == QgsServerSettingsEnv::DEFAULT_VALUE )
450 {
451 return mSettings[ envVar ].defaultVal;
452 }
453 else
454 {
455 return mSettings[ envVar ].val;
456 }
457}
458
459void QgsServerSettings::loadQSettings( const QString &envOptPath ) const
460{
461 if ( ! envOptPath.isEmpty() )
462 {
463 QSettings::setDefaultFormat( QSettings::IniFormat );
464 QSettings::setPath( QSettings::IniFormat, QSettings::UserScope, envOptPath );
465 }
466}
467
468void QgsServerSettings::prioritize( const QMap<QgsServerSettingsEnv::EnvVar, QString> &env )
469{
470 const auto constKeys( env.keys() );
471 for ( const QgsServerSettingsEnv::EnvVar &e : constKeys )
472 {
473 Setting s = mSettings[ e ];
474
475 QVariant varValue;
476 if ( ! env.value( e ).isEmpty() )
477 {
478 varValue.setValue( env.value( e ) );
479 }
480
481 if ( !QgsVariantUtils::isNull( varValue ) && varValue.canConvert( s.type ) )
482 {
483 s.val = varValue;
485 }
486 else if ( ! s.iniKey.isEmpty() && QSettings().contains( s.iniKey ) && QSettings().value( s.iniKey ).canConvert( s.type ) )
487 {
488 s.val = QSettings().value( s.iniKey );
490 }
491 else
492 {
493 s.val = QVariant();
495 }
496
497 // an empty string can be returned from QSettings. In this case, we want
498 // to use the default value
499 if ( s.type == QVariant::String && s.val.toString().isEmpty() )
500 {
501 s.val = QVariant();
503 }
504
505 mSettings[ e ] = s;
506 }
507}
508
510{
511 const QMetaEnum metaEnumEnv( QMetaEnum::fromType<QgsServerSettingsEnv::EnvVar>() );
512 return metaEnumEnv.valueToKey( env );
513}
514
516{
517 const QMetaEnum metaEnumSrc( QMetaEnum::fromType<QgsServerSettingsEnv::Source>() );
518
519 QgsMessageLog::logMessage( "QGIS Server Settings: ", "Server", Qgis::MessageLevel::Info );
520 for ( const Setting &s : std::as_const( mSettings ) )
521 {
522 const QString src = metaEnumSrc.valueToKey( s.src );
523 const QString var = name( s.envVar );
524
525 const QString msg = " - " + var + " / '" + s.iniKey + "' (" + s.descr + "): '" + value( s.envVar ).toString() + "' (read from " + src + ")";
526 QgsMessageLog::logMessage( msg, "Server", Qgis::MessageLevel::Info );
527 }
528
529 if ( ! iniFile().isEmpty() )
530 {
531 const QString msg = "Ini file used to initialize settings: " + iniFile();
532 QgsMessageLog::logMessage( msg, "Server", Qgis::MessageLevel::Info );
533 }
534}
535
536// getter
538{
539 return QSettings().fileName();
540}
541
543{
545}
546
548{
549 return value( QgsServerSettingsEnv::QGIS_SERVER_MAX_THREADS ).toInt();
550}
551
553{
554 return value( QgsServerSettingsEnv::QGIS_SERVER_LOG_FILE ).toString();
555}
556
558{
559 return value( QgsServerSettingsEnv::QGIS_SERVER_LOG_STDERR ).toBool();
560}
561
563{
564 return static_cast<Qgis::MessageLevel>( value( QgsServerSettingsEnv::QGIS_SERVER_LOG_LEVEL ).toInt() );
565}
566
568{
569 return value( QgsServerSettingsEnv::QGIS_PROJECT_FILE ).toString();
570}
571
573{
574 return value( QgsServerSettingsEnv::QGIS_SERVER_CACHE_SIZE ).toLongLong();
575}
576
578{
579 return value( QgsServerSettingsEnv::QGIS_SERVER_CACHE_DIRECTORY ).toString();
580}
581
583{
585}
586
588{
590}
591
593{
595}
596
598{
600}
601
603{
605}
606
608{
610}
611
613{
614 return value( QgsServerSettingsEnv::QGIS_SERVER_LANDING_PAGE_PREFIX, true ).toString();
615}
616
618{
620}
621
623{
624 return value( QgsServerSettingsEnv::QGIS_SERVER_API_WFS3_MAX_LIMIT ).toLongLong();
625}
626
628{
630}
631
633{
635}
636
638{
640}
641
643{
645}
646
648{
649 return value( QgsServerSettingsEnv::QGIS_SERVER_LOG_PROFILE, false ).toBool();
650}
651
652QString QgsServerSettings::serviceUrl( const QString &service ) const
653{
654 QString result;
655 if ( service.compare( QLatin1String( "WMS" ) ) )
656 {
657 result = value( QgsServerSettingsEnv::QGIS_SERVER_WMS_SERVICE_URL ).toString();
658 }
659 else if ( service.compare( QLatin1String( "WFS" ) ) )
660 {
661 result = value( QgsServerSettingsEnv::QGIS_SERVER_WFS_SERVICE_URL ).toString();
662 }
663 else if ( service.compare( QLatin1String( "WCS" ) ) )
664 {
665 result = value( QgsServerSettingsEnv::QGIS_SERVER_WCS_SERVICE_URL ).toString();
666 }
667 else if ( service.compare( QLatin1String( "WMTS" ) ) )
668 {
669 result = value( QgsServerSettingsEnv::QGIS_SERVER_WMTS_SERVICE_URL ).toString();
670 }
671
672 if ( result.isEmpty() )
673 {
674 result = value( QgsServerSettingsEnv::QGIS_SERVER_SERVICE_URL ).toString();
675 }
676
677 return result;
678}
679
681{
683}
684
686{
687 QString result = value( QgsServerSettingsEnv::QGIS_SERVER_PROJECT_CACHE_STRATEGY ).toString();
688 if ( result.compare( QLatin1String( "filesystem" ) ) &&
689 result.compare( QLatin1String( "periodic" ) ) &&
690 result.compare( QLatin1String( "off" ) ) )
691 {
692 QgsMessageLog::logMessage( QStringLiteral( "Invalid cache strategy, expecting 'filesystem', 'periodic' or 'off'. Using 'filesystem' as default." ), "Server", Qgis::MessageLevel::Warning );
693 result = QStringLiteral( "filesystem" );
694 }
695 return result;
696}
697
699{
700 const QString strVal { value( QgsServerSettingsEnv::QGIS_SERVER_ALLOWED_EXTRA_SQL_TOKENS ).toString().trimmed() };
701 if ( strVal.isEmpty() )
702 {
703 return QStringList();
704 }
705 return strVal.split( ',' );
706}
707
709{
710 return value( QgsServerSettingsEnv::QGIS_SERVER_APPLICATION_NAME ).toString().trimmed();
711}
MessageLevel
Level for messages This will be used both for message log and message bar in application.
Definition: qgis.h:115
static QString pkgDataPath()
Returns the common root path of all application data directories.
static QString applicationFullName()
Returns the QGIS application full name.
static QString qgisSettingsDirPath()
Returns the path to the settings directory in user's home dir.
static void logMessage(const QString &message, const QString &tag=QString(), Qgis::MessageLevel level=Qgis::MessageLevel::Warning, bool notifyUser=true)
Adds a message to the log instance (and creates it if necessary).
EnvVar
Environment variables to configure the server.
@ QGIS_SERVER_WCS_SERVICE_URL
To set the WCS service URL if it's not present in the project. (since QGIS 3.20).
@ QGIS_SERVER_WMTS_SERVICE_URL
To set the WMTS service URL if it's not present in the project. (since QGIS 3.20).
@ QGIS_SERVER_IGNORE_BAD_LAYERS
Do not consider the whole project unavailable if it contains bad layers.
@ QGIS_SERVER_ALLOWED_EXTRA_SQL_TOKENS
Set the project cache strategy. Possible values are 'filesystem', 'periodic' or 'off' (since QGIS 3....
@ QGIS_SERVER_TRUST_LAYER_METADATA
Trust layer metadata. Improves project read time. (since QGIS 3.16).
@ QGIS_SERVER_WFS_SERVICE_URL
To set the WFS service URL if it's not present in the project. (since QGIS 3.20).
@ QGIS_SERVER_OVERRIDE_SYSTEM_LOCALE
Override system locale (since QGIS 3.8)
@ QGIS_SERVER_LANDING_PAGE_PROJECTS_PG_CONNECTIONS
PostgreSQL connection strings used by the landing page service to find projects (since QGIS 3....
@ QGIS_SERVER_API_WFS3_MAX_LIMIT
Maximum value for "limit" in a features request, defaults to 10000 (since QGIS 3.10).
@ QGIS_SERVER_API_RESOURCES_DIRECTORY
Base directory where HTML templates and static assets (e.g. images, js and css files) are searched fo...
@ QGIS_SERVER_WMS_MAX_WIDTH
Maximum width for a WMS request. The most conservative between this and the project one is used (sinc...
@ QGIS_SERVER_FORCE_READONLY_LAYERS
Force to open layers in read-only mode. (since QGIS 3.28).
@ QGIS_SERVER_PROJECT_CACHE_STRATEGY
Set the interval for cache invalidation strategy 'interval', default to 0 which select the legacy Fil...
@ QGIS_SERVER_APPLICATION_NAME
Adds these tokens to the list of allowed tokens that the services accept when filtering features (sin...
@ QGIS_SERVER_WMS_MAX_HEIGHT
Maximum height for a WMS request. The most conservative between this and the project one is used (sin...
@ QGIS_SERVER_WMS_SERVICE_URL
To set the WMS service URL if it's not present in the project. (since QGIS 3.20).
@ QGIS_SERVER_DISABLE_GETPRINT
Disabled WMS GetPrint request and don't load layouts. Improves project read time. (since QGIS 3....
@ QGIS_SERVER_PROJECT_CACHE_CHECK_INTERVAL
Prefix of the path component of the landing page base URL, default is empty (since QGIS 3....
@ QGIS_SERVER_SHOW_GROUP_SEPARATOR
Show group (thousands) separator when formatting numeric values, defaults to false (since QGIS 3....
@ QGIS_SERVER_LANDING_PAGE_PROJECTS_DIRECTORIES
Directories used by the landing page service to find .qgs and .qgz projects (since QGIS 3....
@ QGIS_SERVER_LOG_PROFILE
When QGIS_SERVER_LOG_LEVEL is 0 this flag adds to the logs detailed information about the time taken ...
@ QGIS_SERVER_SERVICE_URL
To set the service URL if it's not present in the project. (since QGIS 3.20).
QString serviceUrl(const QString &service) const
Returns the service URL from the setting.
QString cacheDirectory() const
Returns the cache directory.
bool getPrintDisabled() const
Returns true if WMS GetPrint request is disabled and the project's reading flag QgsProject::ReadFlag:...
QString landingPageProjectsPgConnections() const
Returns the PostgreSQL connection strings used by the landing page service to find projects.
int maxThreads() const
Returns the maximum number of threads to use.
bool logStderr() const
Returns whether logging to stderr is activated.
QgsServerSettings()
Constructor.
QString projectFile() const
Returns the QGS project file to use.
QString apiResourcesDirectory() const
Returns the server-wide base directory where HTML templates and static assets (e.g.
int projectCacheCheckInterval() const
Returns the config cache check interval for the 'periodic' strategy.
Qgis::MessageLevel logLevel() const
Returns the log level.
bool logProfile() const
Returns true if profile information has to be added to the logs, default value is false.
QStringList allowedExtraSqlTokens() const
Returns the list of strings that represent the allowed extra SQL tokens accepted as components of a f...
bool forceReadOnlyLayers() const
Returns true if the reading flag force layer read only is activated.
int wmsMaxWidth() const
Returns the server-wide max width of a WMS GetMap request.
static QString name(QgsServerSettingsEnv::EnvVar env)
Returns the string representation of a setting.
QString landingPageBaseUrlPrefix() const
Returns the landing page base URL regular expression, defaults to /.
void logSummary() const
Log a summary of settings currently loaded.
QString logFile() const
Returns the log file.
qlonglong apiWfs3MaxLimit() const
Returns the server-wide maximum allowed value for "limit" in a features request.
int wmsMaxHeight() const
Returns the server-wide max height of a WMS GetMap request.
QString landingPageProjectsDirectories() const
Returns the directories used by the landing page service to find .qgs and .qgz projects.
bool parallelRendering() const
Returns parallel rendering setting.
QString applicationName() const
Returns the QGIS Server application name.
bool showGroupSeparator() const
Show group (thousand) separator.
bool ignoreBadLayers() const
Returns true if the bad layers are ignored and false when the presence of a bad layers invalidates th...
QString iniFile() const
Returns the ini file loaded by QSetting.
QString projectCacheStrategy() const
Returns the project's cache strategy The default value is 'filesystem', the value can be changed by s...
QString overrideSystemLocale() const
Overrides system locale.
bool trustLayerMetadata() const
Returns true if the reading flag trust layer metadata is activated.
void load()
Load settings according to current environment variables.
qint64 cacheSize() const
Returns the cache size.
static bool isNull(const QVariant &variant)
Returns true if the specified variant should be considered a NULL value.