Added settings management (#25)

* Services before refactor

* Added services settings

* Disabled create_service function

* Part of changes - faced problem with geoserver - potential issue

* Added setting self and master passwords

* Settings simple implementation

* Settings Subclass implementation - seems working needs tests

* Settings full implementation

* - Test fixes

Co-authored-by: Alessio Fabiani <alessio.fabiani@geo-solutions.it>

Author: jendrusk

src/geoserver/catalog.py

@@ -27,6 +27,7 @@
 from geoserver.layergroup import LayerGroup, UnsavedLayerGroup
 from geoserver.workspace import workspace_from_index, Workspace
 from geoserver.security import user_from_index
+from geoserver.settings import GlobalSettings
 import os
 import re
 import base64
@@ -144,7 +145,6 @@ def setup_connection(self, retries=3, backoff_factor=0.9):
         self.client.mount(f"{parsed_url.scheme}://", HTTPAdapter(max_retries=retry))
 
     def http_request(self, url, data=None, method='get', headers={}, files=None):
-
         req_method = getattr(self.client, method.lower())
 
         if self.access_token:
@@ -289,6 +289,7 @@ def save(self, obj, content_type="application/xml"):
         netloc = urlparse(self.service_url).netloc
         rest_url = href._replace(netloc=netloc).geturl()
         data = obj.message()
+        print(data)
 
         headers = {
             "Content-type": content_type,
@@ -1384,7 +1385,6 @@ def set_master_pwd(self, new_pwd):
                 "<newMasterPassword>{new_pwd}</newMasterPassword>"
                 "</masterPassword>").format(old_pwd=old_pwd, new_pwd=new_pwd)
         resp = self.http_request(url, method="put", data=body, headers=headers)
-
         if resp.status_code == 200:
             res = new_pwd
             self.reload()
@@ -1408,3 +1408,6 @@ def set_my_pwd(self, new_pwd):
         else:
             raise FailedRequestError(resp.content)
         return res
+
+    def get_global_settings(self):
+        return GlobalSettings(self)

src/geoserver/settings.py

@@ -0,0 +1,178 @@
+# -*- coding: utf-8 -*-
+#########################################################################
+#
+# Copyright 2019, GeoSolutions Sas.
+# Jendrusk also was here
+# All rights reserved.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE.txt file in the root directory of this source tree.
+#
+#########################################################################
+try:
+    from urllib.parse import urljoin
+except BaseException:
+    from urlparse import urljoin
+
+from geoserver.support import (
+    ResourceInfo, StaticResourceInfo,
+    xml_property,
+    read_bool, read_float, read_int, read_string,
+    write_bool, write_float, write_int, write_string)
+
+
+def write_subclass(sbc):
+    def write(builder, sbc):
+        sbc.serialize_all(builder)
+    return write
+
+
+class Contact(StaticResourceInfo):
+    resource_type = "contact"
+
+    def __init__(self, dom):
+        super(Contact, self).__init__()
+        self.dom = dom
+
+    addressCity = xml_property("addressCity", read_string)
+    addressCountry = xml_property("addressCountry", read_string)
+    addressType = xml_property("addressType", read_string)
+    contactEmail = xml_property("contactEmail", read_string)
+    contactOrganization = xml_property("contactOrganization", read_string)
+    contactPerson = xml_property("contactPerson", read_string)
+    contactPosition = xml_property("contactPosition", read_string)
+
+    writers = {
+        "addressCity": write_string("addressCity"),
+        "addressCountry": write_string("addressCountry"),
+        "addressType": write_string("addressType"),
+        "contactEmail": write_string("contactEmail"),
+        "contactOrganization": write_string("contactOrganization"),
+        "contactPerson": write_string("contactPerson"),
+        "contactPosition": write_string("contactPosition")
+    }
+
+
+class Settings(StaticResourceInfo):
+    resource_type = "settings"
+
+    def __init__(self, dom):
+        super(Settings, self).__init__()
+        self.dom = dom
+
+    id = xml_property("id", read_string)
+    contact = xml_property("contact", Contact)
+    charset = xml_property("charset", read_string)
+    numDecimals = xml_property("numDecimals", read_int)
+    onlineResource = xml_property("onlineResource", read_string)
+    verbose = xml_property("verbose", read_bool)
+    verboseExceptions = xml_property("verboseExceptions", read_bool)
+    localWorkspaceIncludesPrefix = xml_property("localWorkspaceIncludesPrefix", read_bool)
+
+    writers = {
+        "id": write_string("id"),
+        "contact": write_subclass("contact"),
+        "charset": write_string("charset"),
+        "numDecimals": write_int("numDecimals"),
+        "onlineResource": write_string("onlineResource"),
+        "verbose": write_bool("verbose"),
+        "verboseExceptions": write_bool("verboseExceptions"),
+        "localWorkspaceIncludesPrefix": write_bool("localWorkspaceIncludesPrefix"),
+    }
+
+
+class Jai(StaticResourceInfo):
+
+    def __init__(self, dom):
+        super(Jai, self).__init__()
+        self.dom = dom
+
+    resource_type = "jai"
+
+    allowInterpolation = xml_property("allowInterpolation", read_bool)
+    recycling = xml_property("recycling", read_bool)
+    tilePriority = xml_property("tilePriority", read_int)
+    tileThreads = xml_property("tileThreads", read_int)
+    memoryCapacity = xml_property("memoryCapacity", read_float)
+    memoryThreshold = xml_property("memoryThreshold", read_float)
+    imageIOCache = xml_property("imageIOCache", read_bool)
+    pngAcceleration = xml_property("pngAcceleration", read_bool)
+    jpegAcceleration = xml_property("jpegAcceleration", read_bool)
+    allowNativeMosaic = xml_property("allowNativeMosaic", read_bool)
+    allowNativeWarp = xml_property("allowNativeWarp", read_bool)
+
+    writers = {
+        "allowInterpolation": write_bool("allowInterpolation"),
+        "recycling": write_bool("recycling"),
+        "tilePriority": write_int("tilePriority"),
+        "tileThreads": write_int("tileThreads"),
+        "memoryCapacity": write_float("memoryCapacity"),
+        "memoryThreshold": write_float("memoryThreshold"),
+        "imageIOCache": write_bool("imageIOCache"),
+        "pngAcceleration": write_bool("pngAcceleration"),
+        "jpegAcceleration": write_bool("jpegAcceleration"),
+        "allowNativeMosaic": write_bool("allowNativeMosaic"),
+        "allowNativeWarp": write_bool("allowNativeWarp")}
+
+
+class CoverageAccess(StaticResourceInfo):
+
+    def __init__(self, dom):
+        super(CoverageAccess, self).__init__()
+        self.dom = dom
+
+    resource_type = "coverageAccess"
+
+    maxPoolSize = xml_property("maxPoolSize", read_int)
+    corePoolSize = xml_property("corePoolSize", read_int)
+    keepAliveTime = xml_property("keepAliveTime", read_int)
+    queueType = xml_property("queueType", read_string)
+    imageIOCacheThreshold = xml_property("imageIOCacheThreshold", read_int)
+
+    writers = {
+        "maxPoolSize": write_int("maxPoolSize"),
+        "corePoolSize": write_int("corePoolSize"),
+        "keepAliveTime": write_int("keepAliveTime"),
+        "queueType": write_string("queueType"),
+        "imageIOCacheThreshold": write_int("imageIOCacheThreshold")
+    }
+
+
+class GlobalSettings(ResourceInfo):
+    resource_type = "global"
+    save_method = "put"
+
+    def __init__(self, catalog):
+        super(GlobalSettings, self).__init__()
+        self._catalog = catalog
+
+    @property
+    def catalog(self):
+        return self._catalog
+
+    @property
+    def href(self):
+        return urljoin(
+            f"{self.catalog.service_url}/",
+            "settings"
+        )
+
+    settings = xml_property("settings", Settings)
+    jai = xml_property("jai", Jai)
+    coverageAccess = xml_property("coverageAccess", CoverageAccess)
+    updateSequence = xml_property("updateSequence", lambda x: int(x.text))
+    featureTypeCacheSize = xml_property("featureTypeCacheSize", lambda x: int(x.text))
+    globalServices = xml_property("globalServices", lambda x: x.text.lower() == 'true')
+    xmlPostRequestLogBufferSize = xml_property("xmlPostRequestLogBufferSize", lambda x: int(x.text))
+
+    writers = {
+        'settings': write_subclass("settings"),
+        'jai': write_subclass("jai"),
+        'coverageAccess': write_subclass("coverageAccess"),
+        'featureTypeCacheSize': write_int("featureTypeCacheSize"),
+        'globalServices': write_bool("globalServices"),
+        'xmlPostRequestLogBufferSize': write_int("xmlPostRequestLogBufferSize")
+    }
+
+    def __repr__(self):
+        return f"settings @ {self.href}"

src/geoserver/support.py

@@ -73,6 +73,8 @@ def clean_segment(segment):
 
 def xml_property(path, converter=lambda x: x.text, default=None):
     def getter(self):
+        if hasattr(self, f"_{path}"):
+            return getattr(self, f"_{path}")
         try:
             if path in self.dirty:
                 return self.dirty[path]
@@ -81,13 +83,17 @@ def getter(self):
                     self.fetch()
                 node = self.dom.find(path)
                 if node is not None:
-                    return converter(self.dom.find(path))
+                    res = converter(self.dom.find(path))
+                    if issubclass(type(res), StaticResourceInfo):
+                        setattr(self, f"_{path}", res)
+                    return res
                 return default
         except Exception as e:
             raise AttributeError(e)
 
     def setter(self, value):
         self.dirty[path] = value
+        x = 1
 
     def delete(self):
         self.dirty[path] = None
@@ -127,6 +133,10 @@ def key_value_pairs(node):
         return dict((entry.attrib['key'], entry.text) for entry in node.findall("entry"))
 
 
+def read_string(node):
+    return node.text
+
+
 def write_string(name):
     def write(builder, value):
         builder.start(name, dict())
@@ -136,6 +146,14 @@ def write(builder, value):
     return write
 
 
+def read_bool(node):
+    text = node.text
+    if text:
+        return text == "true"
+    else:
+        return None
+
+
 def write_bool(name):
     def write(builder, b):
         builder.start(name, dict())
@@ -144,6 +162,15 @@ def write(builder, b):
     return write
 
 
+def read_int(node):
+    text = node.text
+    try:
+        res = int(text)
+        return res
+    except Exception as e:
+        raise ValueError(e)
+
+
 def write_int(name):
     def write(builder, b):
         builder.start(name, dict())
@@ -152,6 +179,23 @@ def write(builder, b):
     return write
 
 
+def read_float(node):
+    text = node.text
+    try:
+        res = float(text)
+        return res
+    except Exception as e:
+        raise ValueError(e)
+
+
+def write_float(name):
+    def write(builder, b):
+        builder.start(name, dict())
+        builder.data(str(b))
+        builder.end(name)
+    return write
+
+
 def write_bbox(name):
     def write(builder, b):
         builder.start(name, dict())
@@ -205,21 +249,20 @@ def write(builder, metadata):
     return write
 
 
-class ResourceInfo(object):
+class StaticResourceInfo(object):
 
     def __init__(self):
+        self.write_all = True
         self.dom = None
         self.dirty = dict()
 
-    def fetch(self):
-        self.dom = self.catalog.get_xml(self.href)
-
-    def clear(self):
-        self.dirty = dict()
-
-    def refresh(self):
-        self.clear()
-        self.fetch()
+    def dirty_all(self):
+        for key in self.writers.keys():
+            attr = getattr(self, key)
+            if issubclass(type(attr), StaticResourceInfo):
+                attr.dirty_all()
+            else:
+                self.dirty[key] = attr
 
     def serialize(self, builder):
         # GeoServer will disable the resource if we omit the <enabled> tag,
@@ -231,18 +274,52 @@ def serialize(self, builder):
             self.dirty['advertised'] = self.advertised
 
         for k, writer in self.writers.items():
-            if k in self.dirty:
-                writer(builder, self.dirty[k])
 
-    def message(self):
-        builder = TreeBuilder()
+            attr = getattr(self, k)
+
+            if issubclass(type(attr), StaticResourceInfo) and attr.dirty:
+                attr.serialize_all(builder)
+            else:
+                if k in self.dirty or self.write_all:
+                    val = self.dirty[k] if self.dirty.get(k) else attr
+                    writer(builder, val)
+
+    def serialize_all(self, builder):
         builder.start(self.resource_type, dict())
         self.serialize(builder)
         builder.end(self.resource_type)
+
+    def message(self):
+        builder = TreeBuilder()
+        self.serialize_all(builder)
         msg = tostring(builder.close())
         return msg
 
 
+class ResourceInfo(StaticResourceInfo):
+
+    def __init__(self):
+        self.write_all = False
+        self.dom = None
+        self.dirty = dict()
+
+    def _clear_subclasses(self):
+        sbcs = [k for k, v in vars(self).items() if issubclass(type(v), StaticResourceInfo)]
+        for sbc in sbcs:
+            delattr(self, sbc)
+
+    def fetch(self):
+        self.dom = self.catalog.get_xml(self.href)
+
+    def clear(self):
+        self.dirty = dict()
+        self._clear_subclasses()
+
+    def refresh(self):
+        self.clear()
+        self.fetch()
+
+
 def prepare_upload_bundle(name, data):
     """GeoServer's REST API uses ZIP archives as containers for file formats such
     as Shapefile and WorldImage which include several 'boxcar' files alongside