def start(args, kill = None):
from pywps import configuration
# TODO: the config file should be "global" to a single server instance and not across all
config_file = os.path.join(os.path.dirname(os.path.abspath(__file__)), "pywps.cfg")
configuration.load_configuration(config_file)
rest_url = '/wpsadmin'
processes = [
FeatureCount(),
SayHello(),
Centroids(),
UltimateQuestion(),
Sleep(),
Buffer(),
Area(),
Box()
]
# List of servers to start up
server_list = [
Server(processes=processes, host='0.0.0.0', port=5001, config_file=config_file),
Server(processes=processes, host='0.0.0.0', port=5002)
]
platform_name = ""
try:
import platform
platform_name = platform.system()
except ImportError, ie:
platform_name = "Windows"
def start(args, kill = None):
config_file = os.path.join(os.path.dirname(os.path.abspath(__file__)), "pywps.cfg")
processes = [
FeatureCount(),
SayHello(),
Centroids(),
UltimateQuestion(),
Sleep(),
Buffer(),
Area(),
Box(),
Warp()
]
s = Server(processes=processes, config_file=config_file)
# TODO: need to spawn a different process for different server
if args.waitress:
import waitress
from pywps import configuration
configuration.load_configuration(config_file)
host = configuration.get_config_value('wps', 'serveraddress').split('://')[1]
port = int(configuration.get_config_value('wps', 'serverport'))
waitress.serve(s.app, host=host, port=port)
else:
s.run()
def start(args, kill=None):
config_file = os.path.join(os.path.dirname(os.path.abspath(__file__)),
"pywps.cfg")
processes = [
FeatureCount(),
SayHello(),
Centroids(),
UltimateQuestion(),
Sleep(),
Buffer(),
Area(),
Box(),
Warp()
]
s = Server(processes=processes, config_file=config_file)
# TODO: need to spawn a different process for different server
if args.waitress:
import waitress
from pywps import configuration
configuration.load_configuration(config_file)
host = configuration.get_config_value('wps',
'serveraddress').split('://')[1]
port = int(configuration.get_config_value('wps', 'serverport'))
waitress.serve(s.app, host=host, port=port)
else:
s.run()
def setUp(self):
configuration.load_configuration()
configuration.CONFIG.set('server', 'language', 'en-US,fr-CA')
self.client = client_for(
Service(processes=[
Process(
lambda: None,
"pr1",
"Process 1",
abstract="Process 1",
translations={
"fr-CA": {
"title": "Processus 1",
"abstract": "Processus 1"
}
},
),
Process(
lambda: None,
"pr2",
"Process 2",
abstract="Process 2",
translations={"fr-CA": {
"title": "Processus 2"
}},
),
]))
def __init__(self, host=None, port=None, debug=False, processes=[], config_file=None):
self.app = flask.Flask(__name__)
# Load config files and override settings if any file specified
if config_file:
configuration.load_configuration(config_file)
self.host = configuration.get_config_value('wps', 'serveraddress').split('://')[1]
self.port = int(configuration.get_config_value('wps', 'serverport'))
# Override config host and port if they are passed to the constructor
if host:
self.host = host
if port:
self.port = port
self.debug = debug
self.output_url = configuration.get_config_value('server', 'outputUrl')
self.output_path = configuration.get_config_value('server', 'outputPath')
self.temp_path = configuration.get_config_value('server', 'tempPath')
# check if in the configuration file specified directory exists otherwise create it
try:
if not os.path.exists(self.temp_path):
os.makedirs(self.temp_path)
print('%s does not exist. Creating it.' % self.temp_path)
if not os.path.exists(self.output_path):
os.makedirs(self.output_path)
print('%s does not exist. Creating it.' % self.output_path)
except Exception as e:
raise NoApplicableCode('File error: Could not create folder. %s' % e)
self.processes = processes
self.service = Service(processes=self.processes)
def _run_job(self, filename):
job = Job.load(filename)
# init config
if 'PYWPS_CFG' in os.environ:
config.load_configuration(os.environ['PYWPS_CFG'])
# update PATH
os.environ['PATH'] = "{0}:{1}".format(
config.get_config_value('processing', 'path'),
os.environ.get('PATH'))
# cd into workdir
os.chdir(job.workdir)
# init logger ... code copied from app.Service
if config.get_config_value('logging',
'file') and config.get_config_value(
'logging', 'level'):
LOGGER.setLevel(
getattr(logging, config.get_config_value('logging', 'level')))
if not LOGGER.handlers: # hasHandlers in Python 3.x
fh = logging.FileHandler(
config.get_config_value('logging', 'file'))
fh.setFormatter(
logging.Formatter(
config.get_config_value('logging', 'format')))
LOGGER.addHandler(fh)
else: # NullHandler
if not LOGGER.handlers:
LOGGER.addHandler(logging.NullHandler())
job.run()
def main():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('-w', '--waitress', action='store_true')
args = parser.parse_args()
config_file = os.path.join(os.path.dirname(os.path.abspath(__file__)), "pywps.cfg")
processes = [
FeatureCount(),
SayHello(),
Centroids(),
UltimateQuestion(),
Sleep(),
Buffer(),
Area(),
Viewshed()
]
s = Server(processes=processes, config_file=config_file)
# TODO: need to spawn a different process for different server
if args.waitress:
import waitress
from pywps import configuration
configuration.load_configuration(config_file)
host = configuration.get_config_value('wps', 'serveraddress').split('://')[1]
port = int(configuration.get_config_value('wps', 'serverport'))
waitress.serve(s.app, host=host, port=port)
else:
s.run()
def test_s3_html_chart_upload():
config.load_configuration(TEST_CFG)
bucket = config.get_config_value("s3", "bucket")
region = config.get_config_value("s3", "region")
location = {'LocationConstraint': region}
client = boto3.client("s3", region_name=region)
client.create_bucket(Bucket=bucket, CreateBucketConfiguration=location)
upload_chart_html_to_S3(TEST_CHART, "abcd")
def config_grass(gisbase):
"""Configure PyWPS to allow GRASS commands."""
conf = configparser.ConfigParser()
conf.add_section('grass')
conf.set('grass', 'gisbase', gisbase)
conf.set('grass', 'gui', 'text')
_, conf_path = tempfile.mkstemp()
with open(conf_path, 'w') as c:
conf.write(c)
config.load_configuration(conf_path)
def config_grass(gisbase):
"""Configure PyWPS to allow GRASS commands."""
conf = configparser.ConfigParser()
conf.add_section('grass')
conf.set('grass', 'gisbase', gisbase)
conf.set('grass', 'gui', 'text')
_, conf_path = tempfile.mkstemp()
with open(conf_path, 'w') as c:
conf.write(c)
config.load_configuration(conf_path)
def __init__(self, cfgfiles=None):
global LOGGER
config.load_configuration(cfgfiles)
LOGGER = get_logger(file=config.get_config_value('logging', 'file'),
level=config.get_config_value('logging', 'level'),
format=config.get_config_value(
'logging', 'format'))
self.max_time = int(config.get_config_value('jobqueue', 'pause'))
self.maxparallel = int(
config.get_config_value('server', 'parallelprocesses'))
def __init__(self, processes=[], cfgfile=None):
self.processes = {p.identifier: p for p in processes}
if cfgfile:
config.load_configuration(cfgfile)
if config.get_config_value('server', 'logfile') and config.get_config_value('server', 'loglevel'):
LOGGER.setLevel(getattr(logging, config.get_config_value('server', 'loglevel')))
msg_fmt = '%(asctime)s] [%(levelname)s] file=%(pathname)s line=%(lineno)s module=%(module)s function=%(funcName)s %(message)s'
fh = logging.FileHandler(config.get_config_value('server', 'logfile'))
fh.setFormatter(logging.Formatter(msg_fmt))
LOGGER.addHandler(fh)
else: # NullHandler
LOGGER.addHandler(logging.NullHandler())
def __init__(self, processes=[], cfgfiles=None):
self.processes = {p.identifier: p for p in processes}
if cfgfiles:
config.load_configuration(cfgfiles)
if config.get_config_value('server', 'logfile') and config.get_config_value('server', 'loglevel'):
LOGGER.setLevel(getattr(logging, config.get_config_value('server', 'loglevel')))
msg_fmt = '%(asctime)s] [%(levelname)s] file=%(pathname)s line=%(lineno)s module=%(module)s function=%(funcName)s %(message)s'
fh = logging.FileHandler(config.get_config_value('server', 'logfile'))
fh.setFormatter(logging.Formatter(msg_fmt))
LOGGER.addHandler(fh)
else: # NullHandler
LOGGER.addHandler(logging.NullHandler())
def get_host(cfgfiles=None):
configuration.load_configuration(cfgfiles)
url = configuration.get_config_value('server', 'url')
url = url or 'http://localhost:5000/wps'
click.echo("starting WPS service on {}".format(url))
parsed_url = urlparse(url)
if ':' in parsed_url.netloc:
host, port = parsed_url.netloc.split(':')
port = int(port)
else:
host = parsed_url.netloc
port = 80
return host, port
def __init__(self, processes=[], cfgfiles=None):
# ordered dict of processes
self.processes = OrderedDict((p.identifier, p) for p in processes)
if cfgfiles:
config.load_configuration(cfgfiles)
if config.get_config_value('logging', 'file') and config.get_config_value('logging', 'level'):
LOGGER.setLevel(getattr(logging, config.get_config_value('logging', 'level')))
if not LOGGER.handlers: # hasHandlers in Python 3.x
fh = logging.FileHandler(config.get_config_value('logging', 'file'))
fh.setFormatter(logging.Formatter(config.get_config_value('logging', 'format')))
LOGGER.addHandler(fh)
else: # NullHandler | StreamHandler
if not LOGGER.handlers:
LOGGER.addHandler(logging.NullHandler())
def __init__(self, processes=[], cfgfiles=None):
# ordered dict of processes
self.processes = OrderedDict((p.identifier, p) for p in processes)
if cfgfiles:
config.load_configuration(cfgfiles)
if config.get_config_value('logging', 'file') and config.get_config_value('logging', 'level'):
LOGGER.setLevel(getattr(logging, config.get_config_value('logging', 'level')))
if not LOGGER.handlers: # hasHandlers in Python 3.x
fh = logging.FileHandler(config.get_config_value('logging', 'file'))
fh.setFormatter(logging.Formatter(config.get_config_value('logging', 'format')))
LOGGER.addHandler(fh)
else: # NullHandler | StreamHandler
if not LOGGER.handlers:
LOGGER.addHandler(logging.NullHandler())
def _run_job(self, filename):
global LOGGER
job = Job.load(filename)
# init config
if 'PYWPS_CFG' in os.environ:
config.load_configuration(os.environ['PYWPS_CFG'])
# update PATH
os.environ['PATH'] = "{0}:{1}".format(
config.get_config_value('processing', 'path'),
os.environ.get('PATH'))
# cd into workdir
os.chdir(job.workdir)
# init logger ... code copied from app.Service
LOGGER = get_logger(file=config.get_config_value('logging', 'file'),
level=config.get_config_value('logging', 'level'),
format=config.get_config_value(
'logging', 'format'))
job.run()
def __init__(self,
host=None,
port=None,
debug=False,
processes=[],
config_file=None):
self.app = flask.Flask(__name__)
# Load config files and override settings if any file specified
if config_file:
configuration.load_configuration(config_file)
self.host = configuration.get_config_value(
'wps', 'serveraddress').split('://')[1]
self.port = int(configuration.get_config_value(
'wps', 'serverport'))
# Override config host and port if they are passed to the constructor
if host:
self.host = host
if port:
self.port = port
self.debug = debug
self.output_url = configuration.get_config_value('server', 'outputUrl')
self.output_path = configuration.get_config_value(
'server', 'outputPath')
self.temp_path = configuration.get_config_value('server', 'workdir')
# check if in the configuration file specified directory exists otherwise create it
try:
if not os.path.exists(self.temp_path):
os.makedirs(self.temp_path)
print('%s does not exist. Creating it.' % self.temp_path)
if not os.path.exists(self.output_path):
os.makedirs(self.output_path)
print('%s does not exist. Creating it.' % self.output_path)
except Exception as e:
raise NoApplicableCode('File error: Could not create folder. %s' %
e)
self.processes = processes
self.service = Service(processes=self.processes)
def _run_job(self, filename):
job = Job.load(filename)
# init config
if 'PYWPS_CFG' in os.environ:
config.load_configuration(os.environ['PYWPS_CFG'])
# update PATH
os.environ['PATH'] = "{0}:{1}".format(
config.get_config_value('processing', 'path'),
os.environ.get('PATH'))
# cd into workdir
os.chdir(job.workdir)
# init logger ... code copied from app.Service
if config.get_config_value('logging', 'file') and config.get_config_value('logging', 'level'):
LOGGER.setLevel(getattr(logging, config.get_config_value('logging', 'level')))
fh = logging.FileHandler(config.get_config_value('logging', 'file'))
fh.setFormatter(logging.Formatter(config.get_config_value('logging', 'format')))
LOGGER.addHandler(fh)
else: # NullHandler
LOGGER.addHandler(logging.NullHandler())
job.run()
def __init__(self, processes=None, cfgfiles=None):
global LOGGER
processes = processes or []
config.load_configuration(cfgfiles)
LOGGER = get_logger(file=config.get_config_value('logging', 'file'),
level=config.get_config_value('logging', 'level'),
format=config.get_config_value(
'logging', 'format'))
if not processes:
# load processes from processes_module.processes_list
pname = config.get_config_value('server', 'processes')
if pname:
pmodule, plist = pname.rsplit('.', 1)
processes = getattr(importlib.import_module(pmodule), plist)
# ordered dict of processes
self.processes = OrderedDict((p.identifier, p) for p in processes)
def load_pywps_config(container, config=None):
# type: (AnySettingsContainer, Optional[Union[str, Dict[str, str]]]) -> ConfigParser
"""
Loads and updates the PyWPS configuration using Weaver settings.
"""
settings = get_settings(container)
if settings.get("weaver.wps_configured"):
LOGGER.debug("Using preloaded internal Weaver WPS configuration.")
return pywps_config.CONFIG
LOGGER.info("Initial load of internal Weaver WPS configuration.")
pywps_config.load_configuration([]) # load defaults
pywps_config.CONFIG.set("logging", "db_echo", "false")
if logging.getLevelName(pywps_config.CONFIG.get("logging",
"level")) <= logging.DEBUG:
pywps_config.CONFIG.set("logging", "level", "INFO")
# update metadata
LOGGER.debug("Updating WPS metadata configuration.")
for setting_name, setting_value in settings.items():
if setting_name.startswith("weaver.wps_metadata"):
pywps_setting = setting_name.replace("weaver.wps_metadata_", "")
pywps_config.CONFIG.set("metadata:main", pywps_setting,
setting_value)
# add weaver configuration keyword if not already provided
wps_keywords = pywps_config.CONFIG.get("metadata:main",
"identification_keywords")
weaver_mode = get_weaver_configuration(settings)
if weaver_mode not in wps_keywords:
wps_keywords += ("," if wps_keywords else "") + weaver_mode
pywps_config.CONFIG.set("metadata:main", "identification_keywords",
wps_keywords)
# add additional config passed as dictionary of {'section.key': 'value'}
if isinstance(config, dict):
for key, value in config.items():
section, key = key.split(".")
pywps_config.CONFIG.set(section, key, value)
# cleanup alternative dict "PYWPS_CFG" which is not expected elsewhere
if isinstance(settings.get("PYWPS_CFG"), dict):
del settings["PYWPS_CFG"]
# set accepted languages aligned with values provided by REST API endpoints
# otherwise, execute request could fail due to languages considered not supported
languages = ", ".join(AcceptLanguage.values())
LOGGER.debug("Setting WPS languages: [%s]", languages)
pywps_config.CONFIG.set("server", "language", languages)
LOGGER.debug("Updating WPS output configuration.")
# find output directory from app config or wps config
if "weaver.wps_output_dir" not in settings:
output_dir = pywps_config.get_config_value("server", "outputpath")
settings["weaver.wps_output_dir"] = output_dir
# ensure the output dir exists if specified
output_dir = get_wps_output_dir(settings)
make_dirs(output_dir, exist_ok=True)
# find output url from app config (path/url) or wps config (url only)
# note: needs to be configured even when using S3 bucket since XML status is provided locally
if "weaver.wps_output_url" not in settings:
output_path = settings.get("weaver.wps_output_path", "").rstrip("/")
if output_path and isinstance(output_path, str):
output_url = os.path.join(get_weaver_url(settings),
output_path.strip("/"))
else:
output_url = pywps_config.get_config_value("server", "outputurl")
settings["weaver.wps_output_url"] = output_url
# apply workdir if provided, otherwise use default
if "weaver.wps_workdir" in settings:
make_dirs(settings["weaver.wps_workdir"], exist_ok=True)
pywps_config.CONFIG.set("server", "workdir",
settings["weaver.wps_workdir"])
# configure S3 bucket if requested, storage of all process outputs
# note:
# credentials and default profile are picked up automatically by 'boto3' from local AWS configs or env vars
# region can also be picked from there unless explicitly provided by weaver config
# warning:
# if we set `(server, storagetype, s3)`, ALL status (including XML) are stored to S3
# to preserve status locally, we set 'file' and override the storage instance during output rewrite in WpsPackage
# we can still make use of the server configurations here to make this overridden storage auto-find its configs
s3_bucket = settings.get("weaver.wps_output_s3_bucket")
pywps_config.CONFIG.set("server", "storagetype", "file")
# pywps_config.CONFIG.set("server", "storagetype", "s3")
if s3_bucket:
LOGGER.debug("Updating WPS S3 bucket configuration.")
import boto3
from botocore.exceptions import ClientError
s3 = boto3.client("s3")
s3_region = settings.get("weaver.wps_output_s3_region",
s3.meta.region_name)
LOGGER.info(
"Validating that S3 [Bucket=%s, Region=%s] exists or creating it.",
s3_bucket, s3_region)
try:
s3.create_bucket(
Bucket=s3_bucket,
CreateBucketConfiguration={"LocationConstraint": s3_region})
LOGGER.info("S3 bucket for WPS output created.")
except ClientError as exc:
if exc.response.get("Error",
{}).get("Code") != "BucketAlreadyExists":
LOGGER.error("Failed setup of S3 bucket for WPS output: [%s]",
exc)
raise
LOGGER.info("S3 bucket for WPS output already exists.")
pywps_config.CONFIG.set("s3", "region", s3_region)
pywps_config.CONFIG.set("s3", "bucket", s3_bucket)
pywps_config.CONFIG.set(
"s3", "public",
"false") # don't automatically push results as publicly accessible
pywps_config.CONFIG.set(
"s3", "encrypt",
"true") # encrypts data server-side, transparent from this side
# enforce back resolved values onto PyWPS config
pywps_config.CONFIG.set("server", "setworkdir", "true")
pywps_config.CONFIG.set("server", "sethomedir", "true")
pywps_config.CONFIG.set("server", "outputpath",
settings["weaver.wps_output_dir"])
pywps_config.CONFIG.set("server", "outputurl",
settings["weaver.wps_output_url"])
pywps_config.CONFIG.set("server", "url", get_wps_url(settings, load=False))
settings["weaver.wps_configured"] = True
return pywps_config.CONFIG
def server_url():
config.load_configuration(cfgfiles=PYWPS_CFG)
url = config.get_config_value("server", "url")
return url
#!/usr/bin/env python3
import requests
import xml.etree.ElementTree as ET
from pywps.configuration import get_config_value, load_configuration
from osgeo import ogr, osr
load_configuration(['pywps.cfg'])
def parse_string(value):
if len(value.split(sep=".")) != 3:
raise Exception("Table name does not consist of 3 parts separated by dots.")
def get_value(node, identifier='response'):
value = None
try:
xlink_key = '{http://www.w3.org/1999/xlink}href'
po_node = node.find('{http://www.opengis.net/wps/1.0.0}ProcessOutputs')
for n in po_node.findall('{http://www.opengis.net/wps/1.0.0}Output'):
if n.find('{http://www.opengis.net/ows/1.1}Identifier').text == identifier:
if identifier == 'response':
value = n.find('{http://www.opengis.net/wps/1.0.0}Data').text
break
else:
ref_node = n.find('{http://www.opengis.net/wps/1.0.0}Reference')
value = ref_node.attrib['{http://www.w3.org/1999/xlink}href']
break
except IndexError:
raise Exception("No output value found (process probably failed)")
