Copy layers styles

geoservercloud/exceptions.py

@@ -0,0 +1,37 @@
+from dataclasses import dataclass, field
+from typing import Any
+
+from requests import Request, Response
+
+
+@dataclass
+class GsDetail:
+ message: str
+ info: dict[str, Any] = field(default_factory=lambda: {})
+
+
+class GsException(Exception):
+ def __init__(
+ self,
+ code: int,
+ detail: GsDetail,
+ parent_request: Request | None = None,
+ parent_response: Response | None = None,
+ ):
+ super().__init__()
+ self.code = code
+ self.detail = detail
+ self.parent_request = parent_request
+ self.parent_response = parent_response
+
+
+class AuthException(GsException):
+ pass
+
+
+class DatastoreMissing(GsException):
+ pass
+
+
+class WorkspaceMissing(GsException):
+ pass

geoservercloud/geoservercloud.py

@@ -37,14 +37,15 @@ def __init__(
  url: str = "http://localhost:9090/geoserver/cloud",
  user: str = "admin",
  password: str = "geoserver", # nosec
+ verifytls: bool = True,
  ) -> None:
 
  self.url: str = url.strip("/")
  self.user: str = user
  self.password: str = password
  self.auth: tuple[str, str] = (user, password)
- self.rest_service: RestService = RestService(url, self.auth)
- self.ows_service: OwsService = OwsService(url, self.auth)
+ self.rest_service: RestService = RestService(url, self.auth, verifytls)
+ self.ows_service: OwsService = OwsService(url, self.auth, verifytls)
  self.wms: WebMapService_1_3_0 | None = None
  self.wmts: WebMapTileService | None = None
  self.default_workspace: str | None = None

geoservercloud/geoservercloudsync.py

@@ -1,5 +1,10 @@
+import json
 from argparse import ArgumentParser
 
+from requests.exceptions import HTTPError
+
+from geoservercloud.exceptions import DatastoreMissing, GsDetail, WorkspaceMissing
+from geoservercloud.models.layer import Layer
 from geoservercloud.services import RestService
 
 
@@ -31,17 +36,23 @@ def __init__(
  dst_url: str,
  dst_user: str,
  dst_password: str,
+ src_verifytls: bool = True,
+ dst_verifytls: bool = True,
  ) -> None:
  self.src_url: str = src_url.strip("/")
  self.src_user: str = src_user
  self.src_password: str = src_password
  self.src_auth: tuple[str, str] = (src_user, src_password)
- self.src_instance: RestService = RestService(src_url, self.src_auth)
+ self.src_instance: RestService = RestService(
+ src_url, self.src_auth, src_verifytls
+ )
  self.dst_url: str = dst_url.strip("/")
  self.dst_user: str = dst_user
  self.dst_password: str = dst_password
  self.dst_auth: tuple[str, str] = (dst_user, dst_password)
- self.dst_instance: RestService = RestService(dst_url, self.dst_auth)
+ self.dst_instance: RestService = RestService(
+ dst_url, self.dst_auth, src_verifytls
+ )
 
  def copy_workspace(
  self, workspace_name: str, deep_copy: bool = False
@@ -163,9 +174,47 @@ def copy_layer(
  layer, status_code = self.src_instance.get_layer(
  workspace_name, feature_type_name
  )
- if isinstance(layer, str):
- return layer, status_code
- return self.dst_instance.update_layer(layer, workspace_name)
+ if (status_code != 200) or isinstance(layer, str):
+ return f"Error: unexpected response {layer}", 500
+ resource, status_code = self.src_instance.get_resource_from_layer(layer)
+ layer_string = json.dumps(layer.asdict())
+ dst_layer = Layer.from_get_response_payload(
+ {
+ "layer": json.loads(
+ layer_string.replace(self.src_instance.url, self.dst_instance.url)
+ )
+ }
+ )
+
+ xml_resource_route = self.src_instance.get_resource_route_from_layer(layer)
+ if xml_resource_route is None:
+ return f"Error: cannot get resource route for {layer}", 500
+ try:
+ self.dst_instance.create_layer_resource(resource, xml_resource_route)
+ except HTTPError:
+ dst_resource = resource.decode().replace(
+ self.src_instance.url, self.dst_instance.url
+ )
+ store = json.loads(dst_resource)["featureType"]["store"]
+ if not self.dst_instance.check_href(store):
+ raise DatastoreMissing(
+ 404,
+ GsDetail(
+ f"Datastore {store['name']} not found",
+ ),
+ )
+ for ws_name, workspace in self.dst_instance.get_workspaces_from_store(
+ store
+ ).items():
+ if not self.dst_instance.check_href(workspace):
+ raise WorkspaceMissing(
+ 404,
+ GsDetail(
+ f"Workspace {ws_name} not found",
+ ),
+ )
+
+ return self.dst_instance.update_layer(dst_layer, workspace_name)
 
  def copy_layer_groups(self, workspace_name: str) -> tuple[str, int]:
  """
@@ -228,20 +277,39 @@ def copy_style(
  """
  Copy a style from source to destination GeoServer instance
  """
-style_definition, status_code = self.src_instance.get_style_definition(
+style_info, status_code = self.src_instance.get_style_info(
  style_name, workspace_name
  )
- if isinstance(style_definition, str):
- return style_definition, status_code
- content, status_code = self.dst_instance.create_style_definition(
- style_name, style_definition, workspace_name
- )
  if self.not_ok(status_code):
+ return f"Error getting {style_info}", status_code
+ style_definition_response = self.src_instance.get_raw_style_definition(
+ style_name, workspace_name, style_info.format
+ )
+ if self.not_ok(style_definition_response.status_code):
+ content: str = style_definition_response.content.decode()
  return content, status_code
- style, status_code = self.src_instance.get_style(style_name, workspace_name)
- if isinstance(style, str):
- return style, status_code
- return self.dst_instance.create_style(style_name, style, workspace_name)
+ try:
+ content, status_code = self.dst_instance.create_style_info(
+ style_name, style_info, workspace_name
+ )
+ if self.not_ok(status_code):
+ return content, status_code
+ except HTTPError:
+ if not self.dst_instance.check_workspace_for_style(style_info):
+ raise WorkspaceMissing(
+ 404,
+ GsDetail(
+ f"Workspace {style_info.workspace_name} not found",
+ ),
+ )
+
+ return self.dst_instance.fill_style_definition(
+ style_name,
+ style_definition_response.content,
+ style_info.format,
+ style_definition_response.headers["content-type"],
+ workspace_name,
+ )
 
  def copy_style_images(self, workspace_name: str | None = None) -> tuple[str, int]:
  """

geoservercloud/models/layer.py

@@ -9,6 +9,7 @@ def __init__(
  self,
  name: str,
  resource_name: str | None = None,
+ resource_href: str | None = None,
  type: str | None = None,
  default_style_name: str | None = None,
  styles: list | None = None,
@@ -19,7 +20,7 @@ def __init__(
  self.type: str | None = type
  self.resource: ReferencedObjectModel | None = None
  if resource_name:
- self.resource = ReferencedObjectModel(resource_name)
+ self.resource = ReferencedObjectModel(resource_name, resource_href)
  self.default_style: ReferencedObjectModel | None = None
  if default_style_name:
  self.default_style = ReferencedObjectModel(default_style_name)
@@ -35,6 +36,15 @@ def resource_name(self) -> str | None:
  def default_style_name(self) -> str | None:
  return self.default_style.name if self.default_style else None
 
+ @property
+ def all_style_names(self) -> set[str]:
+ all_styles = set()
+ if self.default_style_name is not None:
+ all_styles.add(self.default_style_name)
+ if self.styles is not None:
+ all_styles.update(self.styles)
+ return all_styles
+
  @classmethod
  def from_get_response_payload(cls, content: dict):
  layer = content["layer"]
@@ -45,6 +55,7 @@ def from_get_response_payload(cls, content: dict):
  return cls(
  name=layer["name"],
  resource_name=layer["resource"]["name"],
+ resource_href=layer["resource"]["href"],
  type=layer["type"],
  default_style_name=layer["defaultStyle"]["name"],
  styles=styles,
@@ -59,11 +70,17 @@ def asdict(self) -> dict[str, Any]:
  optional_items = {
  "name": self.name,
  "type": self.type,
- "resource": self.resource_name,
- "defaultStyle": self.default_style_name,
+ "defaultStyle": {
+ "name": self.default_style_name,
+ },
  "attribution": self.attribution,
  "queryable": self.queryable,
  }
+ if self.resource is not None:
+ optional_items["resource"] = {
+ "name": self.resource.name,
+ "href": self.resource.href,
+ }
  return EntityModel.add_items_to_dict(content, optional_items)
 
  def post_payload(self) -> dict[str, dict[str, Any]]:

geoservercloud/services/owsservice.py

@@ -10,11 +10,11 @@
 
 
 class OwsService:
- def __init__(self, url: str, auth: tuple[str, str]) -> None:
+ def __init__(self, url: str, auth: tuple[str, str], verifytls: bool = True) -> None:
  self.url: str = url
  self.auth: tuple[str, str] = auth
  self.ows_endpoints = self.OwsEndpoints()
- self.rest_client = RestClient(url, auth)
+ self.rest_client = RestClient(url, auth, verifytls)
 
  def create_wms(self, workspace_name: str | None = None) -> WebMapService_1_3_0:
  if workspace_name is None:

geoservercloud/services/restclient.py

@@ -2,6 +2,8 @@
 
 import requests
 
+from .restlogger import gs_logger
+
 TIMEOUT = 120
 
 
@@ -17,22 +19,31 @@ class RestClient:
  username and password for GeoServer
  """
 
- def __init__(self, url: str, auth: tuple[str, str]) -> None:
+ def __init__(self, url: str, auth: tuple[str, str], verifytls: bool = True) -> None:
  self.url: str = url
  self.auth: tuple[str, str] = auth
+ self.verifytls: bool = verifytls
 
  def get(
  self,
  path: str,
  params: dict[str, str] | None = None,
  headers: dict[str, str] | None = None,
  ) -> requests.Response:
+ full_url = f"{self.url}{path}"
  response: requests.Response = requests.get(
-f"{self.url}{path}",
+full_url,
  params=params,
  headers=headers,
  auth=self.auth,
  timeout=TIMEOUT,
+ verify=self.verifytls,
+ )
+ gs_logger.info(
+ "[GET] (%s) - %s",
+ response.status_code,
+ full_url,
+ extra={"response": response},
  )
  if response.status_code != 404:
  response.raise_for_status()
@@ -46,15 +57,22 @@ def post(
  json: dict[str, dict[str, Any] | Any] | None = None,
  data: bytes | None = None,
  ) -> requests.Response:
-
+ full_url = f"{self.url}{path}"
  response: requests.Response = requests.post(
-f"{self.url}{path}",
+full_url,
  params=params,
  headers=headers,
  json=json,
  data=data,
  auth=self.auth,
  timeout=TIMEOUT,
+ verify=self.verifytls,
+ )
+ gs_logger.info(
+ "[GET] (%s) - %s",
+ response.status_code,
+ full_url,
+ extra={"response": response},
  )
  if response.status_code != 409:
  response.raise_for_status()
@@ -68,14 +86,22 @@ def put(
  json: dict[str, dict[str, Any]] | None = None,
  data: bytes | None = None,
  ) -> requests.Response:
+ full_url = f"{self.url}{path}"
  response: requests.Response = requests.put(
-f"{self.url}{path}",
+full_url,
  params=params,
  headers=headers,
  json=json,
  data=data,
  auth=self.auth,
  timeout=TIMEOUT,
+ verify=self.verifytls,
+ )
+ gs_logger.info(
+ "[GET] (%s) - %s",
+ response.status_code,
+ full_url,
+ extra={"response": response},
  )
  response.raise_for_status()
  return response
@@ -86,12 +112,20 @@ def delete(
  params: dict[str, str] | None = None,
  headers: dict[str, str] | None = None,
  ) -> requests.Response:
+ full_url = f"{self.url}{path}"
  response: requests.Response = requests.delete(
-f"{self.url}{path}",
+full_url,
  params=params,
  headers=headers,
  auth=self.auth,
  timeout=TIMEOUT,
+ verify=self.verifytls,
+ )
+ gs_logger.info(
+ "[GET] (%s) - %s",
+ response.status_code,
+ full_url,
+ extra={"response": response},
  )
  if response.status_code != 404:
  response.raise_for_status()

geoservercloud/services/restlogger.py

@@ -0,0 +1,12 @@
+import logging
+
+time_formatter = logging.Formatter(
+ "{asctime} - {name}:{levelname} - {message}",
+ style="{",
+ datefmt="%Y-%m-%d %H:%M",
+)
+stream_handler = logging.StreamHandler()
+stream_handler.setFormatter(time_formatter)
+gs_logger = logging.getLogger("GS Session")
+gs_logger.setLevel(logging.INFO)
+gs_logger.addHandler(stream_handler)

geoservercloud/exceptions.py

@@ -0,0 +1,37 @@
+from dataclasses import dataclass, field
+from typing import Any
+
+from requests import Request, Response
+
+
+@dataclass
+class GsDetail:
+ message: str
+ info: dict[str, Any] = field(default_factory=lambda: {})
+
+
+class GsException(Exception):
+ def __init__(
+ self,
+ code: int,
+ detail: GsDetail,
+ parent_request: Request | None = None,
+ parent_response: Response | None = None,
+ ):
+ super().__init__()
+ self.code = code
+ self.detail = detail
+ self.parent_request = parent_request
+ self.parent_response = parent_response
+
+
+class AuthException(GsException):
+ pass
+
+
+class DatastoreMissing(GsException):
+ pass
+
+
+class WorkspaceMissing(GsException):
+ pass

geoservercloud/geoservercloud.py

@@ -37,14 +37,15 @@ def __init__(
  url: str = "http://localhost:9090/geoserver/cloud",
  user: str = "admin",
  password: str = "geoserver", # nosec
+ verifytls: bool = True,
  ) -> None:
 
  self.url: str = url.strip("/")
  self.user: str = user
  self.password: str = password
  self.auth: tuple[str, str] = (user, password)
- self.rest_service: RestService = RestService(url, self.auth)
- self.ows_service: OwsService = OwsService(url, self.auth)
+ self.rest_service: RestService = RestService(url, self.auth, verifytls)
+ self.ows_service: OwsService = OwsService(url, self.auth, verifytls)
  self.wms: WebMapService_1_3_0 | None = None
  self.wmts: WebMapTileService | None = None
  self.default_workspace: str | None = None

geoservercloud/geoservercloudsync.py

@@ -1,5 +1,10 @@
+import json
 from argparse import ArgumentParser
 
+from requests.exceptions import HTTPError
+
+from geoservercloud.exceptions import DatastoreMissing, GsDetail, WorkspaceMissing
+from geoservercloud.models.layer import Layer
 from geoservercloud.services import RestService
 
 
@@ -31,17 +36,23 @@ def __init__(
  dst_url: str,
  dst_user: str,
  dst_password: str,
+ src_verifytls: bool = True,
+ dst_verifytls: bool = True,
  ) -> None:
  self.src_url: str = src_url.strip("/")
  self.src_user: str = src_user
  self.src_password: str = src_password
  self.src_auth: tuple[str, str] = (src_user, src_password)
- self.src_instance: RestService = RestService(src_url, self.src_auth)
+ self.src_instance: RestService = RestService(
+ src_url, self.src_auth, src_verifytls
+ )
  self.dst_url: str = dst_url.strip("/")
  self.dst_user: str = dst_user
  self.dst_password: str = dst_password
  self.dst_auth: tuple[str, str] = (dst_user, dst_password)
- self.dst_instance: RestService = RestService(dst_url, self.dst_auth)
+ self.dst_instance: RestService = RestService(
+ dst_url, self.dst_auth, src_verifytls
+ )
 
  def copy_workspace(
  self, workspace_name: str, deep_copy: bool = False
@@ -163,9 +174,47 @@ def copy_layer(
  layer, status_code = self.src_instance.get_layer(
  workspace_name, feature_type_name
  )
- if isinstance(layer, str):
- return layer, status_code
- return self.dst_instance.update_layer(layer, workspace_name)
+ if (status_code != 200) or isinstance(layer, str):
+ return f"Error: unexpected response {layer}", 500
+ resource, status_code = self.src_instance.get_resource_from_layer(layer)
+ layer_string = json.dumps(layer.asdict())
+ dst_layer = Layer.from_get_response_payload(
+ {
+ "layer": json.loads(
+ layer_string.replace(self.src_instance.url, self.dst_instance.url)
+ )
+ }
+ )
+
+ xml_resource_route = self.src_instance.get_resource_route_from_layer(layer)
+ if xml_resource_route is None:
+ return f"Error: cannot get resource route for {layer}", 500
+ try:
+ self.dst_instance.create_layer_resource(resource, xml_resource_route)
+ except HTTPError:
+ dst_resource = resource.decode().replace(
+ self.src_instance.url, self.dst_instance.url
+ )
+ store = json.loads(dst_resource)["featureType"]["store"]
+ if not self.dst_instance.check_href(store):
+ raise DatastoreMissing(
+ 404,
+ GsDetail(
+ f"Datastore {store['name']} not found",
+ ),
+ )
+ for ws_name, workspace in self.dst_instance.get_workspaces_from_store(
+ store
+ ).items():
+ if not self.dst_instance.check_href(workspace):
+ raise WorkspaceMissing(
+ 404,
+ GsDetail(
+ f"Workspace {ws_name} not found",
+ ),
+ )
+
+ return self.dst_instance.update_layer(dst_layer, workspace_name)
 
  def copy_layer_groups(self, workspace_name: str) -> tuple[str, int]:
  """
@@ -228,20 +277,39 @@ def copy_style(
  """
  Copy a style from source to destination GeoServer instance
  """
-style_definition, status_code = self.src_instance.get_style_definition(
+style_info, status_code = self.src_instance.get_style_info(
  style_name, workspace_name
  )
- if isinstance(style_definition, str):
- return style_definition, status_code
- content, status_code = self.dst_instance.create_style_definition(
- style_name, style_definition, workspace_name
- )
  if self.not_ok(status_code):
+ return f"Error getting {style_info}", status_code
+ style_definition_response = self.src_instance.get_raw_style_definition(
+ style_name, workspace_name, style_info.format
+ )
+ if self.not_ok(style_definition_response.status_code):
+ content: str = style_definition_response.content.decode()
  return content, status_code
- style, status_code = self.src_instance.get_style(style_name, workspace_name)
- if isinstance(style, str):
- return style, status_code
- return self.dst_instance.create_style(style_name, style, workspace_name)
+ try:
+ content, status_code = self.dst_instance.create_style_info(
+ style_name, style_info, workspace_name
+ )
+ if self.not_ok(status_code):
+ return content, status_code
+ except HTTPError:
+ if not self.dst_instance.check_workspace_for_style(style_info):
+ raise WorkspaceMissing(
+ 404,
+ GsDetail(
+ f"Workspace {style_info.workspace_name} not found",
+ ),
+ )
+
+ return self.dst_instance.fill_style_definition(
+ style_name,
+ style_definition_response.content,
+ style_info.format,
+ style_definition_response.headers["content-type"],
+ workspace_name,
+ )
 
  def copy_style_images(self, workspace_name: str | None = None) -> tuple[str, int]:
  """

geoservercloud/models/layer.py

@@ -9,6 +9,7 @@ def __init__(
  self,
  name: str,
  resource_name: str | None = None,
+ resource_href: str | None = None,
  type: str | None = None,
  default_style_name: str | None = None,
  styles: list | None = None,
@@ -19,7 +20,7 @@ def __init__(
  self.type: str | None = type
  self.resource: ReferencedObjectModel | None = None
  if resource_name:
- self.resource = ReferencedObjectModel(resource_name)
+ self.resource = ReferencedObjectModel(resource_name, resource_href)
  self.default_style: ReferencedObjectModel | None = None
  if default_style_name:
  self.default_style = ReferencedObjectModel(default_style_name)
@@ -35,6 +36,15 @@ def resource_name(self) -> str | None:
  def default_style_name(self) -> str | None:
  return self.default_style.name if self.default_style else None
 
+ @property
+ def all_style_names(self) -> set[str]:
+ all_styles = set()
+ if self.default_style_name is not None:
+ all_styles.add(self.default_style_name)
+ if self.styles is not None:
+ all_styles.update(self.styles)
+ return all_styles
+
  @classmethod
  def from_get_response_payload(cls, content: dict):
  layer = content["layer"]
@@ -45,6 +55,7 @@ def from_get_response_payload(cls, content: dict):
  return cls(
  name=layer["name"],
  resource_name=layer["resource"]["name"],
+ resource_href=layer["resource"]["href"],
  type=layer["type"],
  default_style_name=layer["defaultStyle"]["name"],
  styles=styles,
@@ -59,11 +70,17 @@ def asdict(self) -> dict[str, Any]:
  optional_items = {
  "name": self.name,
  "type": self.type,
- "resource": self.resource_name,
- "defaultStyle": self.default_style_name,
+ "defaultStyle": {
+ "name": self.default_style_name,
+ },
  "attribution": self.attribution,
  "queryable": self.queryable,
  }
+ if self.resource is not None:
+ optional_items["resource"] = {
+ "name": self.resource.name,
+ "href": self.resource.href,
+ }
  return EntityModel.add_items_to_dict(content, optional_items)
 
  def post_payload(self) -> dict[str, dict[str, Any]]:

geoservercloud/services/owsservice.py

@@ -10,11 +10,11 @@
 
 
 class OwsService:
- def __init__(self, url: str, auth: tuple[str, str]) -> None:
+ def __init__(self, url: str, auth: tuple[str, str], verifytls: bool = True) -> None:
  self.url: str = url
  self.auth: tuple[str, str] = auth
  self.ows_endpoints = self.OwsEndpoints()
- self.rest_client = RestClient(url, auth)
+ self.rest_client = RestClient(url, auth, verifytls)
 
  def create_wms(self, workspace_name: str | None = None) -> WebMapService_1_3_0:
  if workspace_name is None:

geoservercloud/services/restclient.py

@@ -2,6 +2,8 @@
 
 import requests
 
+from .restlogger import gs_logger
+
 TIMEOUT = 120
 
 
@@ -17,22 +19,31 @@ class RestClient:
  username and password for GeoServer
  """
 
- def __init__(self, url: str, auth: tuple[str, str]) -> None:
+ def __init__(self, url: str, auth: tuple[str, str], verifytls: bool = True) -> None:
  self.url: str = url
  self.auth: tuple[str, str] = auth
+ self.verifytls: bool = verifytls
 
  def get(
  self,
  path: str,
  params: dict[str, str] | None = None,
  headers: dict[str, str] | None = None,
  ) -> requests.Response:
+ full_url = f"{self.url}{path}"
  response: requests.Response = requests.get(
-f"{self.url}{path}",
+full_url,
  params=params,
  headers=headers,
  auth=self.auth,
  timeout=TIMEOUT,
+ verify=self.verifytls,
+ )
+ gs_logger.info(
+ "[GET] (%s) - %s",
+ response.status_code,
+ full_url,
+ extra={"response": response},
  )
  if response.status_code != 404:
  response.raise_for_status()
@@ -46,15 +57,22 @@ def post(
  json: dict[str, dict[str, Any] | Any] | None = None,
  data: bytes | None = None,
  ) -> requests.Response:
-
+ full_url = f"{self.url}{path}"
  response: requests.Response = requests.post(
-f"{self.url}{path}",
+full_url,
  params=params,
  headers=headers,
  json=json,
  data=data,
  auth=self.auth,
  timeout=TIMEOUT,
+ verify=self.verifytls,
+ )
+ gs_logger.info(
+ "[GET] (%s) - %s",
+ response.status_code,
+ full_url,
+ extra={"response": response},
  )
  if response.status_code != 409:
  response.raise_for_status()
@@ -68,14 +86,22 @@ def put(
  json: dict[str, dict[str, Any]] | None = None,
  data: bytes | None = None,
  ) -> requests.Response:
+ full_url = f"{self.url}{path}"
  response: requests.Response = requests.put(
-f"{self.url}{path}",
+full_url,
  params=params,
  headers=headers,
  json=json,
  data=data,
  auth=self.auth,
  timeout=TIMEOUT,
+ verify=self.verifytls,
+ )
+ gs_logger.info(
+ "[GET] (%s) - %s",
+ response.status_code,
+ full_url,
+ extra={"response": response},
  )
  response.raise_for_status()
  return response
@@ -86,12 +112,20 @@ def delete(
  params: dict[str, str] | None = None,
  headers: dict[str, str] | None = None,
  ) -> requests.Response:
+ full_url = f"{self.url}{path}"
  response: requests.Response = requests.delete(
-f"{self.url}{path}",
+full_url,
  params=params,
  headers=headers,
  auth=self.auth,
  timeout=TIMEOUT,
+ verify=self.verifytls,
+ )
+ gs_logger.info(
+ "[GET] (%s) - %s",
+ response.status_code,
+ full_url,
+ extra={"response": response},
  )
  if response.status_code != 404:
  response.raise_for_status()

geoservercloud/services/restlogger.py

@@ -0,0 +1,12 @@
+import logging
+
+time_formatter = logging.Formatter(
+ "{asctime} - {name}:{levelname} - {message}",
+ style="{",
+ datefmt="%Y-%m-%d %H:%M",
+)
+stream_handler = logging.StreamHandler()
+stream_handler.setFormatter(time_formatter)
+gs_logger = logging.getLogger("GS Session")
+gs_logger.setLevel(logging.INFO)
+gs_logger.addHandler(stream_handler)

geoservercloud/exceptions.py

@@ -0,0 +1,37 @@
+from dataclasses import dataclass, field
+from typing import Any
+
+from requests import Request, Response
+
+
+@dataclass
+class GsDetail:
+ message: str
+ info: dict[str, Any] = field(default_factory=lambda: {})
+
+
+class GsException(Exception):
+ def __init__(
+ self,
+ code: int,
+ detail: GsDetail,
+ parent_request: Request | None = None,
+ parent_response: Response | None = None,
+ ):
+ super().__init__()
+ self.code = code
+ self.detail = detail
+ self.parent_request = parent_request
+ self.parent_response = parent_response
+
+
+class AuthException(GsException):
+ pass
+
+
+class DatastoreMissing(GsException):
+ pass
+
+
+class WorkspaceMissing(GsException):
+ pass

geoservercloud/geoservercloud.py

@@ -37,14 +37,15 @@ def __init__(
  url: str = "http://localhost:9090/geoserver/cloud",
  user: str = "admin",
  password: str = "geoserver", # nosec
+ verifytls: bool = True,
  ) -> None:
 
  self.url: str = url.strip("/")
  self.user: str = user
  self.password: str = password
  self.auth: tuple[str, str] = (user, password)
- self.rest_service: RestService = RestService(url, self.auth)
- self.ows_service: OwsService = OwsService(url, self.auth)
+ self.rest_service: RestService = RestService(url, self.auth, verifytls)
+ self.ows_service: OwsService = OwsService(url, self.auth, verifytls)
  self.wms: WebMapService_1_3_0 | None = None
  self.wmts: WebMapTileService | None = None
  self.default_workspace: str | None = None

geoservercloud/geoservercloudsync.py

@@ -1,5 +1,10 @@
+import json
 from argparse import ArgumentParser
 
+from requests.exceptions import HTTPError
+
+from geoservercloud.exceptions import DatastoreMissing, GsDetail, WorkspaceMissing
+from geoservercloud.models.layer import Layer
 from geoservercloud.services import RestService
 
 
@@ -31,17 +36,23 @@ def __init__(
  dst_url: str,
  dst_user: str,
  dst_password: str,
+ src_verifytls: bool = True,
+ dst_verifytls: bool = True,
  ) -> None:
  self.src_url: str = src_url.strip("/")
  self.src_user: str = src_user
  self.src_password: str = src_password
  self.src_auth: tuple[str, str] = (src_user, src_password)
- self.src_instance: RestService = RestService(src_url, self.src_auth)
+ self.src_instance: RestService = RestService(
+ src_url, self.src_auth, src_verifytls
+ )
  self.dst_url: str = dst_url.strip("/")
  self.dst_user: str = dst_user
  self.dst_password: str = dst_password
  self.dst_auth: tuple[str, str] = (dst_user, dst_password)
- self.dst_instance: RestService = RestService(dst_url, self.dst_auth)
+ self.dst_instance: RestService = RestService(
+ dst_url, self.dst_auth, src_verifytls
+ )
 
  def copy_workspace(
  self, workspace_name: str, deep_copy: bool = False
@@ -163,9 +174,47 @@ def copy_layer(
  layer, status_code = self.src_instance.get_layer(
  workspace_name, feature_type_name
  )
- if isinstance(layer, str):
- return layer, status_code
- return self.dst_instance.update_layer(layer, workspace_name)
+ if (status_code != 200) or isinstance(layer, str):
+ return f"Error: unexpected response {layer}", 500
+ resource, status_code = self.src_instance.get_resource_from_layer(layer)
+ layer_string = json.dumps(layer.asdict())
+ dst_layer = Layer.from_get_response_payload(
+ {
+ "layer": json.loads(
+ layer_string.replace(self.src_instance.url, self.dst_instance.url)
+ )
+ }
+ )
+
+ xml_resource_route = self.src_instance.get_resource_route_from_layer(layer)
+ if xml_resource_route is None:
+ return f"Error: cannot get resource route for {layer}", 500
+ try:
+ self.dst_instance.create_layer_resource(resource, xml_resource_route)
+ except HTTPError:
+ dst_resource = resource.decode().replace(
+ self.src_instance.url, self.dst_instance.url
+ )
+ store = json.loads(dst_resource)["featureType"]["store"]
+ if not self.dst_instance.check_href(store):
+ raise DatastoreMissing(
+ 404,
+ GsDetail(
+ f"Datastore {store['name']} not found",
+ ),
+ )
+ for ws_name, workspace in self.dst_instance.get_workspaces_from_store(
+ store
+ ).items():
+ if not self.dst_instance.check_href(workspace):
+ raise WorkspaceMissing(
+ 404,
+ GsDetail(
+ f"Workspace {ws_name} not found",
+ ),
+ )
+
+ return self.dst_instance.update_layer(dst_layer, workspace_name)
 
  def copy_layer_groups(self, workspace_name: str) -> tuple[str, int]:
  """
@@ -228,20 +277,39 @@ def copy_style(
  """
  Copy a style from source to destination GeoServer instance
  """
-style_definition, status_code = self.src_instance.get_style_definition(
+style_info, status_code = self.src_instance.get_style_info(
  style_name, workspace_name
  )
- if isinstance(style_definition, str):
- return style_definition, status_code
- content, status_code = self.dst_instance.create_style_definition(
- style_name, style_definition, workspace_name
- )
  if self.not_ok(status_code):
+ return f"Error getting {style_info}", status_code
+ style_definition_response = self.src_instance.get_raw_style_definition(
+ style_name, workspace_name, style_info.format
+ )
+ if self.not_ok(style_definition_response.status_code):
+ content: str = style_definition_response.content.decode()
  return content, status_code
- style, status_code = self.src_instance.get_style(style_name, workspace_name)
- if isinstance(style, str):
- return style, status_code
- return self.dst_instance.create_style(style_name, style, workspace_name)
+ try:
+ content, status_code = self.dst_instance.create_style_info(
+ style_name, style_info, workspace_name
+ )
+ if self.not_ok(status_code):
+ return content, status_code
+ except HTTPError:
+ if not self.dst_instance.check_workspace_for_style(style_info):
+ raise WorkspaceMissing(
+ 404,
+ GsDetail(
+ f"Workspace {style_info.workspace_name} not found",
+ ),
+ )
+
+ return self.dst_instance.fill_style_definition(
+ style_name,
+ style_definition_response.content,
+ style_info.format,
+ style_definition_response.headers["content-type"],
+ workspace_name,
+ )
 
  def copy_style_images(self, workspace_name: str | None = None) -> tuple[str, int]:
  """

geoservercloud/models/layer.py

@@ -9,6 +9,7 @@ def __init__(
  self,
  name: str,
  resource_name: str | None = None,
+ resource_href: str | None = None,
  type: str | None = None,
  default_style_name: str | None = None,
  styles: list | None = None,
@@ -19,7 +20,7 @@ def __init__(
  self.type: str | None = type
  self.resource: ReferencedObjectModel | None = None
  if resource_name:
- self.resource = ReferencedObjectModel(resource_name)
+ self.resource = ReferencedObjectModel(resource_name, resource_href)
  self.default_style: ReferencedObjectModel | None = None
  if default_style_name:
  self.default_style = ReferencedObjectModel(default_style_name)
@@ -35,6 +36,15 @@ def resource_name(self) -> str | None:
  def default_style_name(self) -> str | None:
  return self.default_style.name if self.default_style else None
 
+ @property
+ def all_style_names(self) -> set[str]:
+ all_styles = set()
+ if self.default_style_name is not None:
+ all_styles.add(self.default_style_name)
+ if self.styles is not None:
+ all_styles.update(self.styles)
+ return all_styles
+
  @classmethod
  def from_get_response_payload(cls, content: dict):
  layer = content["layer"]
@@ -45,6 +55,7 @@ def from_get_response_payload(cls, content: dict):
  return cls(
  name=layer["name"],
  resource_name=layer["resource"]["name"],
+ resource_href=layer["resource"]["href"],
  type=layer["type"],
  default_style_name=layer["defaultStyle"]["name"],
  styles=styles,
@@ -59,11 +70,17 @@ def asdict(self) -> dict[str, Any]:
  optional_items = {
  "name": self.name,
  "type": self.type,
- "resource": self.resource_name,
- "defaultStyle": self.default_style_name,
+ "defaultStyle": {
+ "name": self.default_style_name,
+ },
  "attribution": self.attribution,
  "queryable": self.queryable,
  }
+ if self.resource is not None:
+ optional_items["resource"] = {
+ "name": self.resource.name,
+ "href": self.resource.href,
+ }
  return EntityModel.add_items_to_dict(content, optional_items)
 
  def post_payload(self) -> dict[str, dict[str, Any]]:

geoservercloud/services/owsservice.py

@@ -10,11 +10,11 @@
 
 
 class OwsService:
- def __init__(self, url: str, auth: tuple[str, str]) -> None:
+ def __init__(self, url: str, auth: tuple[str, str], verifytls: bool = True) -> None:
  self.url: str = url
  self.auth: tuple[str, str] = auth
  self.ows_endpoints = self.OwsEndpoints()
- self.rest_client = RestClient(url, auth)
+ self.rest_client = RestClient(url, auth, verifytls)
 
  def create_wms(self, workspace_name: str | None = None) -> WebMapService_1_3_0:
  if workspace_name is None:

geoservercloud/services/restclient.py

@@ -2,6 +2,8 @@
 
 import requests
 
+from .restlogger import gs_logger
+
 TIMEOUT = 120
 
 
@@ -17,22 +19,31 @@ class RestClient:
  username and password for GeoServer
  """
 
- def __init__(self, url: str, auth: tuple[str, str]) -> None:
+ def __init__(self, url: str, auth: tuple[str, str], verifytls: bool = True) -> None:
  self.url: str = url
  self.auth: tuple[str, str] = auth
+ self.verifytls: bool = verifytls
 
  def get(
  self,
  path: str,
  params: dict[str, str] | None = None,
  headers: dict[str, str] | None = None,
  ) -> requests.Response:
+ full_url = f"{self.url}{path}"
  response: requests.Response = requests.get(
-f"{self.url}{path}",
+full_url,
  params=params,
  headers=headers,
  auth=self.auth,
  timeout=TIMEOUT,
+ verify=self.verifytls,
+ )
+ gs_logger.info(
+ "[GET] (%s) - %s",
+ response.status_code,
+ full_url,
+ extra={"response": response},
  )
  if response.status_code != 404:
  response.raise_for_status()
@@ -46,15 +57,22 @@ def post(
  json: dict[str, dict[str, Any] | Any] | None = None,
  data: bytes | None = None,
  ) -> requests.Response:
-
+ full_url = f"{self.url}{path}"
  response: requests.Response = requests.post(
-f"{self.url}{path}",
+full_url,
  params=params,
  headers=headers,
  json=json,
  data=data,
  auth=self.auth,
  timeout=TIMEOUT,
+ verify=self.verifytls,
+ )
+ gs_logger.info(
+ "[GET] (%s) - %s",
+ response.status_code,
+ full_url,
+ extra={"response": response},
  )
  if response.status_code != 409:
  response.raise_for_status()
@@ -68,14 +86,22 @@ def put(
  json: dict[str, dict[str, Any]] | None = None,
  data: bytes | None = None,
  ) -> requests.Response:
+ full_url = f"{self.url}{path}"
  response: requests.Response = requests.put(
-f"{self.url}{path}",
+full_url,
  params=params,
  headers=headers,
  json=json,
  data=data,
  auth=self.auth,
  timeout=TIMEOUT,
+ verify=self.verifytls,
+ )
+ gs_logger.info(
+ "[GET] (%s) - %s",
+ response.status_code,
+ full_url,
+ extra={"response": response},
  )
  response.raise_for_status()
  return response
@@ -86,12 +112,20 @@ def delete(
  params: dict[str, str] | None = None,
  headers: dict[str, str] | None = None,
  ) -> requests.Response:
+ full_url = f"{self.url}{path}"
  response: requests.Response = requests.delete(
-f"{self.url}{path}",
+full_url,
  params=params,
  headers=headers,
  auth=self.auth,
  timeout=TIMEOUT,
+ verify=self.verifytls,
+ )
+ gs_logger.info(
+ "[GET] (%s) - %s",
+ response.status_code,
+ full_url,
+ extra={"response": response},
  )
  if response.status_code != 404:
  response.raise_for_status()

geoservercloud/services/restlogger.py

@@ -0,0 +1,12 @@
+import logging
+
+time_formatter = logging.Formatter(
+ "{asctime} - {name}:{levelname} - {message}",
+ style="{",
+ datefmt="%Y-%m-%d %H:%M",
+)
+stream_handler = logging.StreamHandler()
+stream_handler.setFormatter(time_formatter)
+gs_logger = logging.getLogger("GS Session")
+gs_logger.setLevel(logging.INFO)
+gs_logger.addHandler(stream_handler)

geoservercloud/exceptions.py

@@ -0,0 +1,37 @@
+from dataclasses import dataclass, field
+from typing import Any
+
+from requests import Request, Response
+
+
+@dataclass
+class GsDetail:
+ message: str
+ info: dict[str, Any] = field(default_factory=lambda: {})
+
+
+class GsException(Exception):
+ def __init__(
+ self,
+ code: int,
+ detail: GsDetail,
+ parent_request: Request | None = None,
+ parent_response: Response | None = None,
+ ):
+ super().__init__()
+ self.code = code
+ self.detail = detail
+ self.parent_request = parent_request
+ self.parent_response = parent_response
+
+
+class AuthException(GsException):
+ pass
+
+
+class DatastoreMissing(GsException):
+ pass
+
+
+class WorkspaceMissing(GsException):
+ pass

geoservercloud/geoservercloud.py

@@ -37,14 +37,15 @@ def __init__(
  url: str = "http://localhost:9090/geoserver/cloud",
  user: str = "admin",
  password: str = "geoserver", # nosec
+ verifytls: bool = True,
  ) -> None:
 
  self.url: str = url.strip("/")
  self.user: str = user
  self.password: str = password
  self.auth: tuple[str, str] = (user, password)
- self.rest_service: RestService = RestService(url, self.auth)
- self.ows_service: OwsService = OwsService(url, self.auth)
+ self.rest_service: RestService = RestService(url, self.auth, verifytls)
+ self.ows_service: OwsService = OwsService(url, self.auth, verifytls)
  self.wms: WebMapService_1_3_0 | None = None
  self.wmts: WebMapTileService | None = None
  self.default_workspace: str | None = None

geoservercloud/geoservercloudsync.py

@@ -1,5 +1,10 @@
+import json
 from argparse import ArgumentParser
 
+from requests.exceptions import HTTPError
+
+from geoservercloud.exceptions import DatastoreMissing, GsDetail, WorkspaceMissing
+from geoservercloud.models.layer import Layer
 from geoservercloud.services import RestService
 
 
@@ -31,17 +36,23 @@ def __init__(
  dst_url: str,
  dst_user: str,
  dst_password: str,
+ src_verifytls: bool = True,
+ dst_verifytls: bool = True,
  ) -> None:
  self.src_url: str = src_url.strip("/")
  self.src_user: str = src_user
  self.src_password: str = src_password
  self.src_auth: tuple[str, str] = (src_user, src_password)
- self.src_instance: RestService = RestService(src_url, self.src_auth)
+ self.src_instance: RestService = RestService(
+ src_url, self.src_auth, src_verifytls
+ )
  self.dst_url: str = dst_url.strip("/")
  self.dst_user: str = dst_user
  self.dst_password: str = dst_password
  self.dst_auth: tuple[str, str] = (dst_user, dst_password)
- self.dst_instance: RestService = RestService(dst_url, self.dst_auth)
+ self.dst_instance: RestService = RestService(
+ dst_url, self.dst_auth, src_verifytls
+ )
 
  def copy_workspace(
  self, workspace_name: str, deep_copy: bool = False
@@ -163,9 +174,47 @@ def copy_layer(
  layer, status_code = self.src_instance.get_layer(
  workspace_name, feature_type_name
  )
- if isinstance(layer, str):
- return layer, status_code
- return self.dst_instance.update_layer(layer, workspace_name)
+ if (status_code != 200) or isinstance(layer, str):
+ return f"Error: unexpected response {layer}", 500
+ resource, status_code = self.src_instance.get_resource_from_layer(layer)
+ layer_string = json.dumps(layer.asdict())
+ dst_layer = Layer.from_get_response_payload(
+ {
+ "layer": json.loads(
+ layer_string.replace(self.src_instance.url, self.dst_instance.url)
+ )
+ }
+ )
+
+ xml_resource_route = self.src_instance.get_resource_route_from_layer(layer)
+ if xml_resource_route is None:
+ return f"Error: cannot get resource route for {layer}", 500
+ try:
+ self.dst_instance.create_layer_resource(resource, xml_resource_route)
+ except HTTPError:
+ dst_resource = resource.decode().replace(
+ self.src_instance.url, self.dst_instance.url
+ )
+ store = json.loads(dst_resource)["featureType"]["store"]
+ if not self.dst_instance.check_href(store):
+ raise DatastoreMissing(
+ 404,
+ GsDetail(
+ f"Datastore {store['name']} not found",
+ ),
+ )
+ for ws_name, workspace in self.dst_instance.get_workspaces_from_store(
+ store
+ ).items():
+ if not self.dst_instance.check_href(workspace):
+ raise WorkspaceMissing(
+ 404,
+ GsDetail(
+ f"Workspace {ws_name} not found",
+ ),
+ )
+
+ return self.dst_instance.update_layer(dst_layer, workspace_name)
 
  def copy_layer_groups(self, workspace_name: str) -> tuple[str, int]:
  """
@@ -228,20 +277,39 @@ def copy_style(
  """
  Copy a style from source to destination GeoServer instance
  """
-style_definition, status_code = self.src_instance.get_style_definition(
+style_info, status_code = self.src_instance.get_style_info(
  style_name, workspace_name
  )
- if isinstance(style_definition, str):
- return style_definition, status_code
- content, status_code = self.dst_instance.create_style_definition(
- style_name, style_definition, workspace_name
- )
  if self.not_ok(status_code):
+ return f"Error getting {style_info}", status_code
+ style_definition_response = self.src_instance.get_raw_style_definition(
+ style_name, workspace_name, style_info.format
+ )
+ if self.not_ok(style_definition_response.status_code):
+ content: str = style_definition_response.content.decode()
  return content, status_code
- style, status_code = self.src_instance.get_style(style_name, workspace_name)
- if isinstance(style, str):
- return style, status_code
- return self.dst_instance.create_style(style_name, style, workspace_name)
+ try:
+ content, status_code = self.dst_instance.create_style_info(
+ style_name, style_info, workspace_name
+ )
+ if self.not_ok(status_code):
+ return content, status_code
+ except HTTPError:
+ if not self.dst_instance.check_workspace_for_style(style_info):
+ raise WorkspaceMissing(
+ 404,
+ GsDetail(
+ f"Workspace {style_info.workspace_name} not found",
+ ),
+ )
+
+ return self.dst_instance.fill_style_definition(
+ style_name,
+ style_definition_response.content,
+ style_info.format,
+ style_definition_response.headers["content-type"],
+ workspace_name,
+ )
 
  def copy_style_images(self, workspace_name: str | None = None) -> tuple[str, int]:
  """

geoservercloud/models/layer.py

@@ -9,6 +9,7 @@ def __init__(
  self,
  name: str,
  resource_name: str | None = None,
+ resource_href: str | None = None,
  type: str | None = None,
  default_style_name: str | None = None,
  styles: list | None = None,
@@ -19,7 +20,7 @@ def __init__(
  self.type: str | None = type
  self.resource: ReferencedObjectModel | None = None
  if resource_name:
- self.resource = ReferencedObjectModel(resource_name)
+ self.resource = ReferencedObjectModel(resource_name, resource_href)
  self.default_style: ReferencedObjectModel | None = None
  if default_style_name:
  self.default_style = ReferencedObjectModel(default_style_name)
@@ -35,6 +36,15 @@ def resource_name(self) -> str | None:
  def default_style_name(self) -> str | None:
  return self.default_style.name if self.default_style else None
 
+ @property
+ def all_style_names(self) -> set[str]:
+ all_styles = set()
+ if self.default_style_name is not None:
+ all_styles.add(self.default_style_name)
+ if self.styles is not None:
+ all_styles.update(self.styles)
+ return all_styles
+
  @classmethod
  def from_get_response_payload(cls, content: dict):
  layer = content["layer"]
@@ -45,6 +55,7 @@ def from_get_response_payload(cls, content: dict):
  return cls(
  name=layer["name"],
  resource_name=layer["resource"]["name"],
+ resource_href=layer["resource"]["href"],
  type=layer["type"],
  default_style_name=layer["defaultStyle"]["name"],
  styles=styles,
@@ -59,11 +70,17 @@ def asdict(self) -> dict[str, Any]:
  optional_items = {
  "name": self.name,
  "type": self.type,
- "resource": self.resource_name,
- "defaultStyle": self.default_style_name,
+ "defaultStyle": {
+ "name": self.default_style_name,
+ },
  "attribution": self.attribution,
  "queryable": self.queryable,
  }
+ if self.resource is not None:
+ optional_items["resource"] = {
+ "name": self.resource.name,
+ "href": self.resource.href,
+ }
  return EntityModel.add_items_to_dict(content, optional_items)
 
  def post_payload(self) -> dict[str, dict[str, Any]]:

geoservercloud/services/owsservice.py

@@ -10,11 +10,11 @@
 
 
 class OwsService:
- def __init__(self, url: str, auth: tuple[str, str]) -> None:
+ def __init__(self, url: str, auth: tuple[str, str], verifytls: bool = True) -> None:
  self.url: str = url
  self.auth: tuple[str, str] = auth
  self.ows_endpoints = self.OwsEndpoints()
- self.rest_client = RestClient(url, auth)
+ self.rest_client = RestClient(url, auth, verifytls)
 
  def create_wms(self, workspace_name: str | None = None) -> WebMapService_1_3_0:
  if workspace_name is None:

geoservercloud/services/restclient.py

@@ -2,6 +2,8 @@
 
 import requests
 
+from .restlogger import gs_logger
+
 TIMEOUT = 120
 
 
@@ -17,22 +19,31 @@ class RestClient:
  username and password for GeoServer
  """
 
- def __init__(self, url: str, auth: tuple[str, str]) -> None:
+ def __init__(self, url: str, auth: tuple[str, str], verifytls: bool = True) -> None:
  self.url: str = url
  self.auth: tuple[str, str] = auth
+ self.verifytls: bool = verifytls
 
  def get(
  self,
  path: str,
  params: dict[str, str] | None = None,
  headers: dict[str, str] | None = None,
  ) -> requests.Response:
+ full_url = f"{self.url}{path}"
  response: requests.Response = requests.get(
-f"{self.url}{path}",
+full_url,
  params=params,
  headers=headers,
  auth=self.auth,
  timeout=TIMEOUT,
+ verify=self.verifytls,
+ )
+ gs_logger.info(
+ "[GET] (%s) - %s",
+ response.status_code,
+ full_url,
+ extra={"response": response},
  )
  if response.status_code != 404:
  response.raise_for_status()
@@ -46,15 +57,22 @@ def post(
  json: dict[str, dict[str, Any] | Any] | None = None,
  data: bytes | None = None,
  ) -> requests.Response:
-
+ full_url = f"{self.url}{path}"
  response: requests.Response = requests.post(
-f"{self.url}{path}",
+full_url,
  params=params,
  headers=headers,
  json=json,
  data=data,
  auth=self.auth,
  timeout=TIMEOUT,
+ verify=self.verifytls,
+ )
+ gs_logger.info(
+ "[GET] (%s) - %s",
+ response.status_code,
+ full_url,
+ extra={"response": response},
  )
  if response.status_code != 409:
  response.raise_for_status()
@@ -68,14 +86,22 @@ def put(
  json: dict[str, dict[str, Any]] | None = None,
  data: bytes | None = None,
  ) -> requests.Response:
+ full_url = f"{self.url}{path}"
  response: requests.Response = requests.put(
-f"{self.url}{path}",
+full_url,
  params=params,
  headers=headers,
  json=json,
  data=data,
  auth=self.auth,
  timeout=TIMEOUT,
+ verify=self.verifytls,
+ )
+ gs_logger.info(
+ "[GET] (%s) - %s",
+ response.status_code,
+ full_url,
+ extra={"response": response},
  )
  response.raise_for_status()
  return response
@@ -86,12 +112,20 @@ def delete(
  params: dict[str, str] | None = None,
  headers: dict[str, str] | None = None,
  ) -> requests.Response:
+ full_url = f"{self.url}{path}"
  response: requests.Response = requests.delete(
-f"{self.url}{path}",
+full_url,
  params=params,
  headers=headers,
  auth=self.auth,
  timeout=TIMEOUT,
+ verify=self.verifytls,
+ )
+ gs_logger.info(
+ "[GET] (%s) - %s",
+ response.status_code,
+ full_url,
+ extra={"response": response},
  )
  if response.status_code != 404:
  response.raise_for_status()

geoservercloud/services/restlogger.py

@@ -0,0 +1,12 @@
+import logging
+
+time_formatter = logging.Formatter(
+ "{asctime} - {name}:{levelname} - {message}",
+ style="{",
+ datefmt="%Y-%m-%d %H:%M",
+)
+stream_handler = logging.StreamHandler()
+stream_handler.setFormatter(time_formatter)
+gs_logger = logging.getLogger("GS Session")
+gs_logger.setLevel(logging.INFO)
+gs_logger.addHandler(stream_handler)

geoservercloud/exceptions.py

@@ -0,0 +1,37 @@
+from dataclasses import dataclass, field
+from typing import Any
+
+from requests import Request, Response
+
+
+@dataclass
+class GsDetail:
+ message: str
+ info: dict[str, Any] = field(default_factory=lambda: {})
+
+
+class GsException(Exception):
+ def __init__(
+ self,
+ code: int,
+ detail: GsDetail,
+ parent_request: Request | None = None,
+ parent_response: Response | None = None,
+ ):
+ super().__init__()
+ self.code = code
+ self.detail = detail
+ self.parent_request = parent_request
+ self.parent_response = parent_response
+
+
+class AuthException(GsException):
+ pass
+
+
+class DatastoreMissing(GsException):
+ pass
+
+
+class WorkspaceMissing(GsException):
+ pass

geoservercloud/geoservercloud.py

@@ -37,14 +37,15 @@ def __init__(
  url: str = "http://localhost:9090/geoserver/cloud",
  user: str = "admin",
  password: str = "geoserver", # nosec
+ verifytls: bool = True,
  ) -> None:
 
  self.url: str = url.strip("/")
  self.user: str = user
  self.password: str = password
  self.auth: tuple[str, str] = (user, password)
- self.rest_service: RestService = RestService(url, self.auth)
- self.ows_service: OwsService = OwsService(url, self.auth)
+ self.rest_service: RestService = RestService(url, self.auth, verifytls)
+ self.ows_service: OwsService = OwsService(url, self.auth, verifytls)
  self.wms: WebMapService_1_3_0 | None = None
  self.wmts: WebMapTileService | None = None
  self.default_workspace: str | None = None

geoservercloud/geoservercloudsync.py

@@ -1,5 +1,10 @@
+import json
 from argparse import ArgumentParser
 
+from requests.exceptions import HTTPError
+
+from geoservercloud.exceptions import DatastoreMissing, GsDetail, WorkspaceMissing
+from geoservercloud.models.layer import Layer
 from geoservercloud.services import RestService
 
 
@@ -31,17 +36,23 @@ def __init__(
  dst_url: str,
  dst_user: str,
  dst_password: str,
+ src_verifytls: bool = True,
+ dst_verifytls: bool = True,
  ) -> None:
  self.src_url: str = src_url.strip("/")
  self.src_user: str = src_user
  self.src_password: str = src_password
  self.src_auth: tuple[str, str] = (src_user, src_password)
- self.src_instance: RestService = RestService(src_url, self.src_auth)
+ self.src_instance: RestService = RestService(
+ src_url, self.src_auth, src_verifytls
+ )
  self.dst_url: str = dst_url.strip("/")
  self.dst_user: str = dst_user
  self.dst_password: str = dst_password
  self.dst_auth: tuple[str, str] = (dst_user, dst_password)
- self.dst_instance: RestService = RestService(dst_url, self.dst_auth)
+ self.dst_instance: RestService = RestService(
+ dst_url, self.dst_auth, src_verifytls
+ )
 
  def copy_workspace(
  self, workspace_name: str, deep_copy: bool = False
@@ -163,9 +174,47 @@ def copy_layer(
  layer, status_code = self.src_instance.get_layer(
  workspace_name, feature_type_name
  )
- if isinstance(layer, str):
- return layer, status_code
- return self.dst_instance.update_layer(layer, workspace_name)
+ if (status_code != 200) or isinstance(layer, str):
+ return f"Error: unexpected response {layer}", 500
+ resource, status_code = self.src_instance.get_resource_from_layer(layer)
+ layer_string = json.dumps(layer.asdict())
+ dst_layer = Layer.from_get_response_payload(
+ {
+ "layer": json.loads(
+ layer_string.replace(self.src_instance.url, self.dst_instance.url)
+ )
+ }
+ )
+
+ xml_resource_route = self.src_instance.get_resource_route_from_layer(layer)
+ if xml_resource_route is None:
+ return f"Error: cannot get resource route for {layer}", 500
+ try:
+ self.dst_instance.create_layer_resource(resource, xml_resource_route)
+ except HTTPError:
+ dst_resource = resource.decode().replace(
+ self.src_instance.url, self.dst_instance.url
+ )
+ store = json.loads(dst_resource)["featureType"]["store"]
+ if not self.dst_instance.check_href(store):
+ raise DatastoreMissing(
+ 404,
+ GsDetail(
+ f"Datastore {store['name']} not found",
+ ),
+ )
+ for ws_name, workspace in self.dst_instance.get_workspaces_from_store(
+ store
+ ).items():
+ if not self.dst_instance.check_href(workspace):
+ raise WorkspaceMissing(
+ 404,
+ GsDetail(
+ f"Workspace {ws_name} not found",
+ ),
+ )
+
+ return self.dst_instance.update_layer(dst_layer, workspace_name)
 
  def copy_layer_groups(self, workspace_name: str) -> tuple[str, int]:
  """
@@ -228,20 +277,39 @@ def copy_style(
  """
  Copy a style from source to destination GeoServer instance
  """
-style_definition, status_code = self.src_instance.get_style_definition(
+style_info, status_code = self.src_instance.get_style_info(
  style_name, workspace_name
  )
- if isinstance(style_definition, str):
- return style_definition, status_code
- content, status_code = self.dst_instance.create_style_definition(
- style_name, style_definition, workspace_name
- )
  if self.not_ok(status_code):
+ return f"Error getting {style_info}", status_code
+ style_definition_response = self.src_instance.get_raw_style_definition(
+ style_name, workspace_name, style_info.format
+ )
+ if self.not_ok(style_definition_response.status_code):
+ content: str = style_definition_response.content.decode()
  return content, status_code
- style, status_code = self.src_instance.get_style(style_name, workspace_name)
- if isinstance(style, str):
- return style, status_code
- return self.dst_instance.create_style(style_name, style, workspace_name)
+ try:
+ content, status_code = self.dst_instance.create_style_info(
+ style_name, style_info, workspace_name
+ )
+ if self.not_ok(status_code):
+ return content, status_code
+ except HTTPError:
+ if not self.dst_instance.check_workspace_for_style(style_info):
+ raise WorkspaceMissing(
+ 404,
+ GsDetail(
+ f"Workspace {style_info.workspace_name} not found",
+ ),
+ )
+
+ return self.dst_instance.fill_style_definition(
+ style_name,
+ style_definition_response.content,
+ style_info.format,
+ style_definition_response.headers["content-type"],
+ workspace_name,
+ )
 
  def copy_style_images(self, workspace_name: str | None = None) -> tuple[str, int]:
  """

geoservercloud/models/layer.py

@@ -9,6 +9,7 @@ def __init__(
  self,
  name: str,
  resource_name: str | None = None,
+ resource_href: str | None = None,
  type: str | None = None,
  default_style_name: str | None = None,
  styles: list | None = None,
@@ -19,7 +20,7 @@ def __init__(
  self.type: str | None = type
  self.resource: ReferencedObjectModel | None = None
  if resource_name:
- self.resource = ReferencedObjectModel(resource_name)
+ self.resource = ReferencedObjectModel(resource_name, resource_href)
  self.default_style: ReferencedObjectModel | None = None
  if default_style_name:
  self.default_style = ReferencedObjectModel(default_style_name)
@@ -35,6 +36,15 @@ def resource_name(self) -> str | None:
  def default_style_name(self) -> str | None:
  return self.default_style.name if self.default_style else None
 
+ @property
+ def all_style_names(self) -> set[str]:
+ all_styles = set()
+ if self.default_style_name is not None:
+ all_styles.add(self.default_style_name)
+ if self.styles is not None:
+ all_styles.update(self.styles)
+ return all_styles
+
  @classmethod
  def from_get_response_payload(cls, content: dict):
  layer = content["layer"]
@@ -45,6 +55,7 @@ def from_get_response_payload(cls, content: dict):
  return cls(
  name=layer["name"],
  resource_name=layer["resource"]["name"],
+ resource_href=layer["resource"]["href"],
  type=layer["type"],
  default_style_name=layer["defaultStyle"]["name"],
  styles=styles,
@@ -59,11 +70,17 @@ def asdict(self) -> dict[str, Any]:
  optional_items = {
  "name": self.name,
  "type": self.type,
- "resource": self.resource_name,
- "defaultStyle": self.default_style_name,
+ "defaultStyle": {
+ "name": self.default_style_name,
+ },
  "attribution": self.attribution,
  "queryable": self.queryable,
  }
+ if self.resource is not None:
+ optional_items["resource"] = {
+ "name": self.resource.name,
+ "href": self.resource.href,
+ }
  return EntityModel.add_items_to_dict(content, optional_items)
 
  def post_payload(self) -> dict[str, dict[str, Any]]:

geoservercloud/services/owsservice.py

@@ -10,11 +10,11 @@
 
 
 class OwsService:
- def __init__(self, url: str, auth: tuple[str, str]) -> None:
+ def __init__(self, url: str, auth: tuple[str, str], verifytls: bool = True) -> None:
  self.url: str = url
  self.auth: tuple[str, str] = auth
  self.ows_endpoints = self.OwsEndpoints()
- self.rest_client = RestClient(url, auth)
+ self.rest_client = RestClient(url, auth, verifytls)
 
  def create_wms(self, workspace_name: str | None = None) -> WebMapService_1_3_0:
  if workspace_name is None:

geoservercloud/services/restclient.py

@@ -2,6 +2,8 @@
 
 import requests
 
+from .restlogger import gs_logger
+
 TIMEOUT = 120
 
 
@@ -17,22 +19,31 @@ class RestClient:
  username and password for GeoServer
  """
 
- def __init__(self, url: str, auth: tuple[str, str]) -> None:
+ def __init__(self, url: str, auth: tuple[str, str], verifytls: bool = True) -> None:
  self.url: str = url
  self.auth: tuple[str, str] = auth
+ self.verifytls: bool = verifytls
 
  def get(
  self,
  path: str,
  params: dict[str, str] | None = None,
  headers: dict[str, str] | None = None,
  ) -> requests.Response:
+ full_url = f"{self.url}{path}"
  response: requests.Response = requests.get(
-f"{self.url}{path}",
+full_url,
  params=params,
  headers=headers,
  auth=self.auth,
  timeout=TIMEOUT,
+ verify=self.verifytls,
+ )
+ gs_logger.info(
+ "[GET] (%s) - %s",
+ response.status_code,
+ full_url,
+ extra={"response": response},
  )
  if response.status_code != 404:
  response.raise_for_status()
@@ -46,15 +57,22 @@ def post(
  json: dict[str, dict[str, Any] | Any] | None = None,
  data: bytes | None = None,
  ) -> requests.Response:
-
+ full_url = f"{self.url}{path}"
  response: requests.Response = requests.post(
-f"{self.url}{path}",
+full_url,
  params=params,
  headers=headers,
  json=json,
  data=data,
  auth=self.auth,
  timeout=TIMEOUT,
+ verify=self.verifytls,
+ )
+ gs_logger.info(
+ "[GET] (%s) - %s",
+ response.status_code,
+ full_url,
+ extra={"response": response},
  )
  if response.status_code != 409:
  response.raise_for_status()
@@ -68,14 +86,22 @@ def put(
  json: dict[str, dict[str, Any]] | None = None,
  data: bytes | None = None,
  ) -> requests.Response:
+ full_url = f"{self.url}{path}"
  response: requests.Response = requests.put(
-f"{self.url}{path}",
+full_url,
  params=params,
  headers=headers,
  json=json,
  data=data,
  auth=self.auth,
  timeout=TIMEOUT,
+ verify=self.verifytls,
+ )
+ gs_logger.info(
+ "[GET] (%s) - %s",
+ response.status_code,
+ full_url,
+ extra={"response": response},
  )
  response.raise_for_status()
  return response
@@ -86,12 +112,20 @@ def delete(
  params: dict[str, str] | None = None,
  headers: dict[str, str] | None = None,
  ) -> requests.Response:
+ full_url = f"{self.url}{path}"
  response: requests.Response = requests.delete(
-f"{self.url}{path}",
+full_url,
  params=params,
  headers=headers,
  auth=self.auth,
  timeout=TIMEOUT,
+ verify=self.verifytls,
+ )
+ gs_logger.info(
+ "[GET] (%s) - %s",
+ response.status_code,
+ full_url,
+ extra={"response": response},
  )
  if response.status_code != 404:
  response.raise_for_status()

geoservercloud/services/restlogger.py

@@ -0,0 +1,12 @@
+import logging
+
+time_formatter = logging.Formatter(
+ "{asctime} - {name}:{levelname} - {message}",
+ style="{",
+ datefmt="%Y-%m-%d %H:%M",
+)
+stream_handler = logging.StreamHandler()
+stream_handler.setFormatter(time_formatter)
+gs_logger = logging.getLogger("GS Session")
+gs_logger.setLevel(logging.INFO)
+gs_logger.addHandler(stream_handler)

geoservercloud/exceptions.py

@@ -0,0 +1,37 @@
+from dataclasses import dataclass, field
+from typing import Any
+
+from requests import Request, Response
+
+
+@dataclass
+class GsDetail:
+ message: str
+ info: dict[str, Any] = field(default_factory=lambda: {})
+
+
+class GsException(Exception):
+ def __init__(
+ self,
+ code: int,
+ detail: GsDetail,
+ parent_request: Request | None = None,
+ parent_response: Response | None = None,
+ ):
+ super().__init__()
+ self.code = code
+ self.detail = detail
+ self.parent_request = parent_request
+ self.parent_response = parent_response
+
+
+class AuthException(GsException):
+ pass
+
+
+class DatastoreMissing(GsException):
+ pass
+
+
+class WorkspaceMissing(GsException):
+ pass

geoservercloud/geoservercloud.py

@@ -37,14 +37,15 @@ def __init__(
  url: str = "http://localhost:9090/geoserver/cloud",
  user: str = "admin",
  password: str = "geoserver", # nosec
+ verifytls: bool = True,
  ) -> None:
 
  self.url: str = url.strip("/")
  self.user: str = user
  self.password: str = password
  self.auth: tuple[str, str] = (user, password)
- self.rest_service: RestService = RestService(url, self.auth)
- self.ows_service: OwsService = OwsService(url, self.auth)
+ self.rest_service: RestService = RestService(url, self.auth, verifytls)
+ self.ows_service: OwsService = OwsService(url, self.auth, verifytls)
  self.wms: WebMapService_1_3_0 | None = None
  self.wmts: WebMapTileService | None = None
  self.default_workspace: str | None = None

geoservercloud/geoservercloudsync.py

@@ -1,5 +1,10 @@
+import json
 from argparse import ArgumentParser
 
+from requests.exceptions import HTTPError
+
+from geoservercloud.exceptions import DatastoreMissing, GsDetail, WorkspaceMissing
+from geoservercloud.models.layer import Layer
 from geoservercloud.services import RestService
 
 
@@ -31,17 +36,23 @@ def __init__(
  dst_url: str,
  dst_user: str,
  dst_password: str,
+ src_verifytls: bool = True,
+ dst_verifytls: bool = True,
  ) -> None:
  self.src_url: str = src_url.strip("/")
  self.src_user: str = src_user
  self.src_password: str = src_password
  self.src_auth: tuple[str, str] = (src_user, src_password)
- self.src_instance: RestService = RestService(src_url, self.src_auth)
+ self.src_instance: RestService = RestService(
+ src_url, self.src_auth, src_verifytls
+ )
  self.dst_url: str = dst_url.strip("/")
  self.dst_user: str = dst_user
  self.dst_password: str = dst_password
  self.dst_auth: tuple[str, str] = (dst_user, dst_password)
- self.dst_instance: RestService = RestService(dst_url, self.dst_auth)
+ self.dst_instance: RestService = RestService(
+ dst_url, self.dst_auth, src_verifytls
+ )
 
  def copy_workspace(
  self, workspace_name: str, deep_copy: bool = False
@@ -163,9 +174,47 @@ def copy_layer(
  layer, status_code = self.src_instance.get_layer(
  workspace_name, feature_type_name
  )
- if isinstance(layer, str):
- return layer, status_code
- return self.dst_instance.update_layer(layer, workspace_name)
+ if (status_code != 200) or isinstance(layer, str):
+ return f"Error: unexpected response {layer}", 500
+ resource, status_code = self.src_instance.get_resource_from_layer(layer)
+ layer_string = json.dumps(layer.asdict())
+ dst_layer = Layer.from_get_response_payload(
+ {
+ "layer": json.loads(
+ layer_string.replace(self.src_instance.url, self.dst_instance.url)
+ )
+ }
+ )
+
+ xml_resource_route = self.src_instance.get_resource_route_from_layer(layer)
+ if xml_resource_route is None:
+ return f"Error: cannot get resource route for {layer}", 500
+ try:
+ self.dst_instance.create_layer_resource(resource, xml_resource_route)
+ except HTTPError:
+ dst_resource = resource.decode().replace(
+ self.src_instance.url, self.dst_instance.url
+ )
+ store = json.loads(dst_resource)["featureType"]["store"]
+ if not self.dst_instance.check_href(store):
+ raise DatastoreMissing(
+ 404,
+ GsDetail(
+ f"Datastore {store['name']} not found",
+ ),
+ )
+ for ws_name, workspace in self.dst_instance.get_workspaces_from_store(
+ store
+ ).items():
+ if not self.dst_instance.check_href(workspace):
+ raise WorkspaceMissing(
+ 404,
+ GsDetail(
+ f"Workspace {ws_name} not found",
+ ),
+ )
+
+ return self.dst_instance.update_layer(dst_layer, workspace_name)
 
  def copy_layer_groups(self, workspace_name: str) -> tuple[str, int]:
  """
@@ -228,20 +277,39 @@ def copy_style(
  """
  Copy a style from source to destination GeoServer instance
  """
-style_definition, status_code = self.src_instance.get_style_definition(
+style_info, status_code = self.src_instance.get_style_info(
  style_name, workspace_name
  )
- if isinstance(style_definition, str):
- return style_definition, status_code
- content, status_code = self.dst_instance.create_style_definition(
- style_name, style_definition, workspace_name
- )
  if self.not_ok(status_code):
+ return f"Error getting {style_info}", status_code
+ style_definition_response = self.src_instance.get_raw_style_definition(
+ style_name, workspace_name, style_info.format
+ )
+ if self.not_ok(style_definition_response.status_code):
+ content: str = style_definition_response.content.decode()
  return content, status_code
- style, status_code = self.src_instance.get_style(style_name, workspace_name)
- if isinstance(style, str):
- return style, status_code
- return self.dst_instance.create_style(style_name, style, workspace_name)
+ try:
+ content, status_code = self.dst_instance.create_style_info(
+ style_name, style_info, workspace_name
+ )
+ if self.not_ok(status_code):
+ return content, status_code
+ except HTTPError:
+ if not self.dst_instance.check_workspace_for_style(style_info):
+ raise WorkspaceMissing(
+ 404,
+ GsDetail(
+ f"Workspace {style_info.workspace_name} not found",
+ ),
+ )
+
+ return self.dst_instance.fill_style_definition(
+ style_name,
+ style_definition_response.content,
+ style_info.format,
+ style_definition_response.headers["content-type"],
+ workspace_name,
+ )
 
  def copy_style_images(self, workspace_name: str | None = None) -> tuple[str, int]:
  """

geoservercloud/models/layer.py

@@ -9,6 +9,7 @@ def __init__(
  self,
  name: str,
  resource_name: str | None = None,
+ resource_href: str | None = None,
  type: str | None = None,
  default_style_name: str | None = None,
  styles: list | None = None,
@@ -19,7 +20,7 @@ def __init__(
  self.type: str | None = type
  self.resource: ReferencedObjectModel | None = None
  if resource_name:
- self.resource = ReferencedObjectModel(resource_name)
+ self.resource = ReferencedObjectModel(resource_name, resource_href)
  self.default_style: ReferencedObjectModel | None = None
  if default_style_name:
  self.default_style = ReferencedObjectModel(default_style_name)
@@ -35,6 +36,15 @@ def resource_name(self) -> str | None:
  def default_style_name(self) -> str | None:
  return self.default_style.name if self.default_style else None
 
+ @property
+ def all_style_names(self) -> set[str]:
+ all_styles = set()
+ if self.default_style_name is not None:
+ all_styles.add(self.default_style_name)
+ if self.styles is not None:
+ all_styles.update(self.styles)
+ return all_styles
+
  @classmethod
  def from_get_response_payload(cls, content: dict):
  layer = content["layer"]
@@ -45,6 +55,7 @@ def from_get_response_payload(cls, content: dict):
  return cls(
  name=layer["name"],
  resource_name=layer["resource"]["name"],
+ resource_href=layer["resource"]["href"],
  type=layer["type"],
  default_style_name=layer["defaultStyle"]["name"],
  styles=styles,
@@ -59,11 +70,17 @@ def asdict(self) -> dict[str, Any]:
  optional_items = {
  "name": self.name,
  "type": self.type,
- "resource": self.resource_name,
- "defaultStyle": self.default_style_name,
+ "defaultStyle": {
+ "name": self.default_style_name,
+ },
  "attribution": self.attribution,
  "queryable": self.queryable,
  }
+ if self.resource is not None:
+ optional_items["resource"] = {
+ "name": self.resource.name,
+ "href": self.resource.href,
+ }
  return EntityModel.add_items_to_dict(content, optional_items)
 
  def post_payload(self) -> dict[str, dict[str, Any]]:

geoservercloud/services/owsservice.py

@@ -10,11 +10,11 @@
 
 
 class OwsService:
- def __init__(self, url: str, auth: tuple[str, str]) -> None:
+ def __init__(self, url: str, auth: tuple[str, str], verifytls: bool = True) -> None:
  self.url: str = url
  self.auth: tuple[str, str] = auth
  self.ows_endpoints = self.OwsEndpoints()
- self.rest_client = RestClient(url, auth)
+ self.rest_client = RestClient(url, auth, verifytls)
 
  def create_wms(self, workspace_name: str | None = None) -> WebMapService_1_3_0:
  if workspace_name is None:

geoservercloud/services/restclient.py

@@ -2,6 +2,8 @@
 
 import requests
 
+from .restlogger import gs_logger
+
 TIMEOUT = 120
 
 
@@ -17,22 +19,31 @@ class RestClient:
  username and password for GeoServer
  """
 
- def __init__(self, url: str, auth: tuple[str, str]) -> None:
+ def __init__(self, url: str, auth: tuple[str, str], verifytls: bool = True) -> None:
  self.url: str = url
  self.auth: tuple[str, str] = auth
+ self.verifytls: bool = verifytls
 
  def get(
  self,
  path: str,
  params: dict[str, str] | None = None,
  headers: dict[str, str] | None = None,
  ) -> requests.Response:
+ full_url = f"{self.url}{path}"
  response: requests.Response = requests.get(
-f"{self.url}{path}",
+full_url,
  params=params,
  headers=headers,
  auth=self.auth,
  timeout=TIMEOUT,
+ verify=self.verifytls,
+ )
+ gs_logger.info(
+ "[GET] (%s) - %s",
+ response.status_code,
+ full_url,
+ extra={"response": response},
  )
  if response.status_code != 404:
  response.raise_for_status()
@@ -46,15 +57,22 @@ def post(
  json: dict[str, dict[str, Any] | Any] | None = None,
  data: bytes | None = None,
  ) -> requests.Response:
-
+ full_url = f"{self.url}{path}"
  response: requests.Response = requests.post(
-f"{self.url}{path}",
+full_url,
  params=params,
  headers=headers,
  json=json,
  data=data,
  auth=self.auth,
  timeout=TIMEOUT,
+ verify=self.verifytls,
+ )
+ gs_logger.info(
+ "[GET] (%s) - %s",
+ response.status_code,
+ full_url,
+ extra={"response": response},
  )
  if response.status_code != 409:
  response.raise_for_status()
@@ -68,14 +86,22 @@ def put(
  json: dict[str, dict[str, Any]] | None = None,
  data: bytes | None = None,
  ) -> requests.Response:
+ full_url = f"{self.url}{path}"
  response: requests.Response = requests.put(
-f"{self.url}{path}",
+full_url,
  params=params,
  headers=headers,
  json=json,
  data=data,
  auth=self.auth,
  timeout=TIMEOUT,
+ verify=self.verifytls,
+ )
+ gs_logger.info(
+ "[GET] (%s) - %s",
+ response.status_code,
+ full_url,
+ extra={"response": response},
  )
  response.raise_for_status()
  return response
@@ -86,12 +112,20 @@ def delete(
  params: dict[str, str] | None = None,
  headers: dict[str, str] | None = None,
  ) -> requests.Response:
+ full_url = f"{self.url}{path}"
  response: requests.Response = requests.delete(
-f"{self.url}{path}",
+full_url,
  params=params,
  headers=headers,
  auth=self.auth,
  timeout=TIMEOUT,
+ verify=self.verifytls,
+ )
+ gs_logger.info(
+ "[GET] (%s) - %s",
+ response.status_code,
+ full_url,
+ extra={"response": response},
  )
  if response.status_code != 404:
  response.raise_for_status()

geoservercloud/services/restlogger.py

@@ -0,0 +1,12 @@
+import logging
+
+time_formatter = logging.Formatter(
+ "{asctime} - {name}:{levelname} - {message}",
+ style="{",
+ datefmt="%Y-%m-%d %H:%M",
+)
+stream_handler = logging.StreamHandler()
+stream_handler.setFormatter(time_formatter)
+gs_logger = logging.getLogger("GS Session")
+gs_logger.setLevel(logging.INFO)
+gs_logger.addHandler(stream_handler)

geoservercloud/exceptions.py

@@ -0,0 +1,37 @@
+from dataclasses import dataclass, field
+from typing import Any
+
+from requests import Request, Response
+
+
+@dataclass
+class GsDetail:
+ message: str
+ info: dict[str, Any] = field(default_factory=lambda: {})
+
+
+class GsException(Exception):
+ def __init__(
+ self,
+ code: int,
+ detail: GsDetail,
+ parent_request: Request | None = None,
+ parent_response: Response | None = None,
+ ):
+ super().__init__()
+ self.code = code
+ self.detail = detail
+ self.parent_request = parent_request
+ self.parent_response = parent_response
+
+
+class AuthException(GsException):
+ pass
+
+
+class DatastoreMissing(GsException):
+ pass
+
+
+class WorkspaceMissing(GsException):
+ pass

geoservercloud/geoservercloud.py

@@ -37,14 +37,15 @@ def __init__(
  url: str = "http://localhost:9090/geoserver/cloud",
  user: str = "admin",
  password: str = "geoserver", # nosec
+ verifytls: bool = True,
  ) -> None:
 
  self.url: str = url.strip("/")
  self.user: str = user
  self.password: str = password
  self.auth: tuple[str, str] = (user, password)
- self.rest_service: RestService = RestService(url, self.auth)
- self.ows_service: OwsService = OwsService(url, self.auth)
+ self.rest_service: RestService = RestService(url, self.auth, verifytls)
+ self.ows_service: OwsService = OwsService(url, self.auth, verifytls)
  self.wms: WebMapService_1_3_0 | None = None
  self.wmts: WebMapTileService | None = None
  self.default_workspace: str | None = None

geoservercloud/geoservercloudsync.py

@@ -1,5 +1,10 @@
+import json
 from argparse import ArgumentParser
 
+from requests.exceptions import HTTPError
+
+from geoservercloud.exceptions import DatastoreMissing, GsDetail, WorkspaceMissing
+from geoservercloud.models.layer import Layer
 from geoservercloud.services import RestService
 
 
@@ -31,17 +36,23 @@ def __init__(
  dst_url: str,
  dst_user: str,
  dst_password: str,
+ src_verifytls: bool = True,
+ dst_verifytls: bool = True,
  ) -> None:
  self.src_url: str = src_url.strip("/")
  self.src_user: str = src_user
  self.src_password: str = src_password
  self.src_auth: tuple[str, str] = (src_user, src_password)
- self.src_instance: RestService = RestService(src_url, self.src_auth)
+ self.src_instance: RestService = RestService(
+ src_url, self.src_auth, src_verifytls
+ )
  self.dst_url: str = dst_url.strip("/")
  self.dst_user: str = dst_user
  self.dst_password: str = dst_password
  self.dst_auth: tuple[str, str] = (dst_user, dst_password)
- self.dst_instance: RestService = RestService(dst_url, self.dst_auth)
+ self.dst_instance: RestService = RestService(
+ dst_url, self.dst_auth, src_verifytls
+ )
 
  def copy_workspace(
  self, workspace_name: str, deep_copy: bool = False
@@ -163,9 +174,47 @@ def copy_layer(
  layer, status_code = self.src_instance.get_layer(
  workspace_name, feature_type_name
  )
- if isinstance(layer, str):
- return layer, status_code
- return self.dst_instance.update_layer(layer, workspace_name)
+ if (status_code != 200) or isinstance(layer, str):
+ return f"Error: unexpected response {layer}", 500
+ resource, status_code = self.src_instance.get_resource_from_layer(layer)
+ layer_string = json.dumps(layer.asdict())
+ dst_layer = Layer.from_get_response_payload(
+ {
+ "layer": json.loads(
+ layer_string.replace(self.src_instance.url, self.dst_instance.url)
+ )
+ }
+ )
+
+ xml_resource_route = self.src_instance.get_resource_route_from_layer(layer)
+ if xml_resource_route is None:
+ return f"Error: cannot get resource route for {layer}", 500
+ try:
+ self.dst_instance.create_layer_resource(resource, xml_resource_route)
+ except HTTPError:
+ dst_resource = resource.decode().replace(
+ self.src_instance.url, self.dst_instance.url
+ )
+ store = json.loads(dst_resource)["featureType"]["store"]
+ if not self.dst_instance.check_href(store):
+ raise DatastoreMissing(
+ 404,
+ GsDetail(
+ f"Datastore {store['name']} not found",
+ ),
+ )
+ for ws_name, workspace in self.dst_instance.get_workspaces_from_store(
+ store
+ ).items():
+ if not self.dst_instance.check_href(workspace):
+ raise WorkspaceMissing(
+ 404,
+ GsDetail(
+ f"Workspace {ws_name} not found",
+ ),
+ )
+
+ return self.dst_instance.update_layer(dst_layer, workspace_name)
 
  def copy_layer_groups(self, workspace_name: str) -> tuple[str, int]:
  """
@@ -228,20 +277,39 @@ def copy_style(
  """
  Copy a style from source to destination GeoServer instance
  """
-style_definition, status_code = self.src_instance.get_style_definition(
+style_info, status_code = self.src_instance.get_style_info(
  style_name, workspace_name
  )
- if isinstance(style_definition, str):
- return style_definition, status_code
- content, status_code = self.dst_instance.create_style_definition(
- style_name, style_definition, workspace_name
- )
  if self.not_ok(status_code):
+ return f"Error getting {style_info}", status_code
+ style_definition_response = self.src_instance.get_raw_style_definition(
+ style_name, workspace_name, style_info.format
+ )
+ if self.not_ok(style_definition_response.status_code):
+ content: str = style_definition_response.content.decode()
  return content, status_code
- style, status_code = self.src_instance.get_style(style_name, workspace_name)
- if isinstance(style, str):
- return style, status_code
- return self.dst_instance.create_style(style_name, style, workspace_name)
+ try:
+ content, status_code = self.dst_instance.create_style_info(
+ style_name, style_info, workspace_name
+ )
+ if self.not_ok(status_code):
+ return content, status_code
+ except HTTPError:
+ if not self.dst_instance.check_workspace_for_style(style_info):
+ raise WorkspaceMissing(
+ 404,
+ GsDetail(
+ f"Workspace {style_info.workspace_name} not found",
+ ),
+ )
+
+ return self.dst_instance.fill_style_definition(
+ style_name,
+ style_definition_response.content,
+ style_info.format,
+ style_definition_response.headers["content-type"],
+ workspace_name,
+ )
 
  def copy_style_images(self, workspace_name: str | None = None) -> tuple[str, int]:
  """

geoservercloud/models/layer.py

@@ -9,6 +9,7 @@ def __init__(
  self,
  name: str,
  resource_name: str | None = None,
+ resource_href: str | None = None,
  type: str | None = None,
  default_style_name: str | None = None,
  styles: list | None = None,
@@ -19,7 +20,7 @@ def __init__(
  self.type: str | None = type
  self.resource: ReferencedObjectModel | None = None
  if resource_name:
- self.resource = ReferencedObjectModel(resource_name)
+ self.resource = ReferencedObjectModel(resource_name, resource_href)
  self.default_style: ReferencedObjectModel | None = None
  if default_style_name:
  self.default_style = ReferencedObjectModel(default_style_name)
@@ -35,6 +36,15 @@ def resource_name(self) -> str | None:
  def default_style_name(self) -> str | None:
  return self.default_style.name if self.default_style else None
 
+ @property
+ def all_style_names(self) -> set[str]:
+ all_styles = set()
+ if self.default_style_name is not None:
+ all_styles.add(self.default_style_name)
+ if self.styles is not None:
+ all_styles.update(self.styles)
+ return all_styles
+
  @classmethod
  def from_get_response_payload(cls, content: dict):
  layer = content["layer"]
@@ -45,6 +55,7 @@ def from_get_response_payload(cls, content: dict):
  return cls(
  name=layer["name"],
  resource_name=layer["resource"]["name"],
+ resource_href=layer["resource"]["href"],
  type=layer["type"],
  default_style_name=layer["defaultStyle"]["name"],
  styles=styles,
@@ -59,11 +70,17 @@ def asdict(self) -> dict[str, Any]:
  optional_items = {
  "name": self.name,
  "type": self.type,
- "resource": self.resource_name,
- "defaultStyle": self.default_style_name,
+ "defaultStyle": {
+ "name": self.default_style_name,
+ },
  "attribution": self.attribution,
  "queryable": self.queryable,
  }
+ if self.resource is not None:
+ optional_items["resource"] = {
+ "name": self.resource.name,
+ "href": self.resource.href,
+ }
  return EntityModel.add_items_to_dict(content, optional_items)
 
  def post_payload(self) -> dict[str, dict[str, Any]]:

geoservercloud/services/owsservice.py

@@ -10,11 +10,11 @@
 
 
 class OwsService:
- def __init__(self, url: str, auth: tuple[str, str]) -> None:
+ def __init__(self, url: str, auth: tuple[str, str], verifytls: bool = True) -> None:
  self.url: str = url
  self.auth: tuple[str, str] = auth
  self.ows_endpoints = self.OwsEndpoints()
- self.rest_client = RestClient(url, auth)
+ self.rest_client = RestClient(url, auth, verifytls)
 
  def create_wms(self, workspace_name: str | None = None) -> WebMapService_1_3_0:
  if workspace_name is None:

geoservercloud/services/restclient.py

@@ -2,6 +2,8 @@
 
 import requests
 
+from .restlogger import gs_logger
+
 TIMEOUT = 120
 
 
@@ -17,22 +19,31 @@ class RestClient:
  username and password for GeoServer
  """
 
- def __init__(self, url: str, auth: tuple[str, str]) -> None:
+ def __init__(self, url: str, auth: tuple[str, str], verifytls: bool = True) -> None:
  self.url: str = url
  self.auth: tuple[str, str] = auth
+ self.verifytls: bool = verifytls
 
  def get(
  self,
  path: str,
  params: dict[str, str] | None = None,
  headers: dict[str, str] | None = None,
  ) -> requests.Response:
+ full_url = f"{self.url}{path}"
  response: requests.Response = requests.get(
-f"{self.url}{path}",
+full_url,
  params=params,
  headers=headers,
  auth=self.auth,
  timeout=TIMEOUT,
+ verify=self.verifytls,
+ )
+ gs_logger.info(
+ "[GET] (%s) - %s",
+ response.status_code,
+ full_url,
+ extra={"response": response},
  )
  if response.status_code != 404:
  response.raise_for_status()
@@ -46,15 +57,22 @@ def post(
  json: dict[str, dict[str, Any] | Any] | None = None,
  data: bytes | None = None,
  ) -> requests.Response:
-
+ full_url = f"{self.url}{path}"
  response: requests.Response = requests.post(
-f"{self.url}{path}",
+full_url,
  params=params,
  headers=headers,
  json=json,
  data=data,
  auth=self.auth,
  timeout=TIMEOUT,
+ verify=self.verifytls,
+ )
+ gs_logger.info(
+ "[GET] (%s) - %s",
+ response.status_code,
+ full_url,
+ extra={"response": response},
  )
  if response.status_code != 409:
  response.raise_for_status()
@@ -68,14 +86,22 @@ def put(
  json: dict[str, dict[str, Any]] | None = None,
  data: bytes | None = None,
  ) -> requests.Response:
+ full_url = f"{self.url}{path}"
  response: requests.Response = requests.put(
-f"{self.url}{path}",
+full_url,
  params=params,
  headers=headers,
  json=json,
  data=data,
  auth=self.auth,
  timeout=TIMEOUT,
+ verify=self.verifytls,
+ )
+ gs_logger.info(
+ "[GET] (%s) - %s",
+ response.status_code,
+ full_url,
+ extra={"response": response},
  )
  response.raise_for_status()
  return response
@@ -86,12 +112,20 @@ def delete(
  params: dict[str, str] | None = None,
  headers: dict[str, str] | None = None,
  ) -> requests.Response:
+ full_url = f"{self.url}{path}"
  response: requests.Response = requests.delete(
-f"{self.url}{path}",
+full_url,
  params=params,
  headers=headers,
  auth=self.auth,
  timeout=TIMEOUT,
+ verify=self.verifytls,
+ )
+ gs_logger.info(
+ "[GET] (%s) - %s",
+ response.status_code,
+ full_url,
+ extra={"response": response},
  )
  if response.status_code != 404:
  response.raise_for_status()

geoservercloud/services/restlogger.py

@@ -0,0 +1,12 @@
+import logging
+
+time_formatter = logging.Formatter(
+ "{asctime} - {name}:{levelname} - {message}",
+ style="{",
+ datefmt="%Y-%m-%d %H:%M",
+)
+stream_handler = logging.StreamHandler()
+stream_handler.setFormatter(time_formatter)
+gs_logger = logging.getLogger("GS Session")
+gs_logger.setLevel(logging.INFO)
+gs_logger.addHandler(stream_handler)

geoservercloud/exceptions.py

@@ -0,0 +1,37 @@
+from dataclasses import dataclass, field
+from typing import Any
+
+from requests import Request, Response
+
+
+@dataclass
+class GsDetail:
+ message: str
+ info: dict[str, Any] = field(default_factory=lambda: {})
+
+
+class GsException(Exception):
+ def __init__(
+ self,
+ code: int,
+ detail: GsDetail,
+ parent_request: Request | None = None,
+ parent_response: Response | None = None,
+ ):
+ super().__init__()
+ self.code = code
+ self.detail = detail
+ self.parent_request = parent_request
+ self.parent_response = parent_response
+
+
+class AuthException(GsException):
+ pass
+
+
+class DatastoreMissing(GsException):
+ pass
+
+
+class WorkspaceMissing(GsException):
+ pass

geoservercloud/geoservercloud.py

@@ -37,14 +37,15 @@ def __init__(
  url: str = "http://localhost:9090/geoserver/cloud",
  user: str = "admin",
  password: str = "geoserver", # nosec
+ verifytls: bool = True,
  ) -> None:
 
  self.url: str = url.strip("/")
  self.user: str = user
  self.password: str = password
  self.auth: tuple[str, str] = (user, password)
- self.rest_service: RestService = RestService(url, self.auth)
- self.ows_service: OwsService = OwsService(url, self.auth)
+ self.rest_service: RestService = RestService(url, self.auth, verifytls)
+ self.ows_service: OwsService = OwsService(url, self.auth, verifytls)
  self.wms: WebMapService_1_3_0 | None = None
  self.wmts: WebMapTileService | None = None
  self.default_workspace: str | None = None

geoservercloud/geoservercloudsync.py

@@ -1,5 +1,10 @@
+import json
 from argparse import ArgumentParser
 
+from requests.exceptions import HTTPError
+
+from geoservercloud.exceptions import DatastoreMissing, GsDetail, WorkspaceMissing
+from geoservercloud.models.layer import Layer
 from geoservercloud.services import RestService
 
 
@@ -31,17 +36,23 @@ def __init__(
  dst_url: str,
  dst_user: str,
  dst_password: str,
+ src_verifytls: bool = True,
+ dst_verifytls: bool = True,
  ) -> None:
  self.src_url: str = src_url.strip("/")
  self.src_user: str = src_user
  self.src_password: str = src_password
  self.src_auth: tuple[str, str] = (src_user, src_password)
- self.src_instance: RestService = RestService(src_url, self.src_auth)
+ self.src_instance: RestService = RestService(
+ src_url, self.src_auth, src_verifytls
+ )
  self.dst_url: str = dst_url.strip("/")
  self.dst_user: str = dst_user
  self.dst_password: str = dst_password
  self.dst_auth: tuple[str, str] = (dst_user, dst_password)
- self.dst_instance: RestService = RestService(dst_url, self.dst_auth)
+ self.dst_instance: RestService = RestService(
+ dst_url, self.dst_auth, src_verifytls
+ )
 
  def copy_workspace(
  self, workspace_name: str, deep_copy: bool = False
@@ -163,9 +174,47 @@ def copy_layer(
  layer, status_code = self.src_instance.get_layer(
  workspace_name, feature_type_name
  )
- if isinstance(layer, str):
- return layer, status_code
- return self.dst_instance.update_layer(layer, workspace_name)
+ if (status_code != 200) or isinstance(layer, str):
+ return f"Error: unexpected response {layer}", 500
+ resource, status_code = self.src_instance.get_resource_from_layer(layer)
+ layer_string = json.dumps(layer.asdict())
+ dst_layer = Layer.from_get_response_payload(
+ {
+ "layer": json.loads(
+ layer_string.replace(self.src_instance.url, self.dst_instance.url)
+ )
+ }
+ )
+
+ xml_resource_route = self.src_instance.get_resource_route_from_layer(layer)
+ if xml_resource_route is None:
+ return f"Error: cannot get resource route for {layer}", 500
+ try:
+ self.dst_instance.create_layer_resource(resource, xml_resource_route)
+ except HTTPError:
+ dst_resource = resource.decode().replace(
+ self.src_instance.url, self.dst_instance.url
+ )
+ store = json.loads(dst_resource)["featureType"]["store"]
+ if not self.dst_instance.check_href(store):
+ raise DatastoreMissing(
+ 404,
+ GsDetail(
+ f"Datastore {store['name']} not found",
+ ),
+ )
+ for ws_name, workspace in self.dst_instance.get_workspaces_from_store(
+ store
+ ).items():
+ if not self.dst_instance.check_href(workspace):
+ raise WorkspaceMissing(
+ 404,
+ GsDetail(
+ f"Workspace {ws_name} not found",
+ ),
+ )
+
+ return self.dst_instance.update_layer(dst_layer, workspace_name)
 
  def copy_layer_groups(self, workspace_name: str) -> tuple[str, int]:
  """
@@ -228,20 +277,39 @@ def copy_style(
  """
  Copy a style from source to destination GeoServer instance
  """
-style_definition, status_code = self.src_instance.get_style_definition(
+style_info, status_code = self.src_instance.get_style_info(
  style_name, workspace_name
  )
- if isinstance(style_definition, str):
- return style_definition, status_code
- content, status_code = self.dst_instance.create_style_definition(
- style_name, style_definition, workspace_name
- )
  if self.not_ok(status_code):
+ return f"Error getting {style_info}", status_code
+ style_definition_response = self.src_instance.get_raw_style_definition(
+ style_name, workspace_name, style_info.format
+ )
+ if self.not_ok(style_definition_response.status_code):
+ content: str = style_definition_response.content.decode()
  return content, status_code
- style, status_code = self.src_instance.get_style(style_name, workspace_name)
- if isinstance(style, str):
- return style, status_code
- return self.dst_instance.create_style(style_name, style, workspace_name)
+ try:
+ content, status_code = self.dst_instance.create_style_info(
+ style_name, style_info, workspace_name
+ )
+ if self.not_ok(status_code):
+ return content, status_code
+ except HTTPError:
+ if not self.dst_instance.check_workspace_for_style(style_info):
+ raise WorkspaceMissing(
+ 404,
+ GsDetail(
+ f"Workspace {style_info.workspace_name} not found",
+ ),
+ )
+
+ return self.dst_instance.fill_style_definition(
+ style_name,
+ style_definition_response.content,
+ style_info.format,
+ style_definition_response.headers["content-type"],
+ workspace_name,
+ )
 
  def copy_style_images(self, workspace_name: str | None = None) -> tuple[str, int]:
  """

geoservercloud/models/layer.py

@@ -9,6 +9,7 @@ def __init__(
  self,
  name: str,
  resource_name: str | None = None,
+ resource_href: str | None = None,
  type: str | None = None,
  default_style_name: str | None = None,
  styles: list | None = None,
@@ -19,7 +20,7 @@ def __init__(
  self.type: str | None = type
  self.resource: ReferencedObjectModel | None = None
  if resource_name:
- self.resource = ReferencedObjectModel(resource_name)
+ self.resource = ReferencedObjectModel(resource_name, resource_href)
  self.default_style: ReferencedObjectModel | None = None
  if default_style_name:
  self.default_style = ReferencedObjectModel(default_style_name)
@@ -35,6 +36,15 @@ def resource_name(self) -> str | None:
  def default_style_name(self) -> str | None:
  return self.default_style.name if self.default_style else None
 
+ @property
+ def all_style_names(self) -> set[str]:
+ all_styles = set()
+ if self.default_style_name is not None:
+ all_styles.add(self.default_style_name)
+ if self.styles is not None:
+ all_styles.update(self.styles)
+ return all_styles
+
  @classmethod
  def from_get_response_payload(cls, content: dict):
  layer = content["layer"]
@@ -45,6 +55,7 @@ def from_get_response_payload(cls, content: dict):
  return cls(
  name=layer["name"],
  resource_name=layer["resource"]["name"],
+ resource_href=layer["resource"]["href"],
  type=layer["type"],
  default_style_name=layer["defaultStyle"]["name"],
  styles=styles,
@@ -59,11 +70,17 @@ def asdict(self) -> dict[str, Any]:
  optional_items = {
  "name": self.name,
  "type": self.type,
- "resource": self.resource_name,
- "defaultStyle": self.default_style_name,
+ "defaultStyle": {
+ "name": self.default_style_name,
+ },
  "attribution": self.attribution,
  "queryable": self.queryable,
  }
+ if self.resource is not None:
+ optional_items["resource"] = {
+ "name": self.resource.name,
+ "href": self.resource.href,
+ }
  return EntityModel.add_items_to_dict(content, optional_items)
 
  def post_payload(self) -> dict[str, dict[str, Any]]:

geoservercloud/services/owsservice.py

@@ -10,11 +10,11 @@
 
 
 class OwsService:
- def __init__(self, url: str, auth: tuple[str, str]) -> None:
+ def __init__(self, url: str, auth: tuple[str, str], verifytls: bool = True) -> None:
  self.url: str = url
  self.auth: tuple[str, str] = auth
  self.ows_endpoints = self.OwsEndpoints()
- self.rest_client = RestClient(url, auth)
+ self.rest_client = RestClient(url, auth, verifytls)
 
  def create_wms(self, workspace_name: str | None = None) -> WebMapService_1_3_0:
  if workspace_name is None:

geoservercloud/services/restclient.py

@@ -2,6 +2,8 @@
 
 import requests
 
+from .restlogger import gs_logger
+
 TIMEOUT = 120
 
 
@@ -17,22 +19,31 @@ class RestClient:
  username and password for GeoServer
  """
 
- def __init__(self, url: str, auth: tuple[str, str]) -> None:
+ def __init__(self, url: str, auth: tuple[str, str], verifytls: bool = True) -> None:
  self.url: str = url
  self.auth: tuple[str, str] = auth
+ self.verifytls: bool = verifytls
 
  def get(
  self,
  path: str,
  params: dict[str, str] | None = None,
  headers: dict[str, str] | None = None,
  ) -> requests.Response:
+ full_url = f"{self.url}{path}"
  response: requests.Response = requests.get(
-f"{self.url}{path}",
+full_url,
  params=params,
  headers=headers,
  auth=self.auth,
  timeout=TIMEOUT,
+ verify=self.verifytls,
+ )
+ gs_logger.info(
+ "[GET] (%s) - %s",
+ response.status_code,
+ full_url,
+ extra={"response": response},
  )
  if response.status_code != 404:
  response.raise_for_status()
@@ -46,15 +57,22 @@ def post(
  json: dict[str, dict[str, Any] | Any] | None = None,
  data: bytes | None = None,
  ) -> requests.Response:
-
+ full_url = f"{self.url}{path}"
  response: requests.Response = requests.post(
-f"{self.url}{path}",
+full_url,
  params=params,
  headers=headers,
  json=json,
  data=data,
  auth=self.auth,
  timeout=TIMEOUT,
+ verify=self.verifytls,
+ )
+ gs_logger.info(
+ "[GET] (%s) - %s",
+ response.status_code,
+ full_url,
+ extra={"response": response},
  )
  if response.status_code != 409:
  response.raise_for_status()
@@ -68,14 +86,22 @@ def put(
  json: dict[str, dict[str, Any]] | None = None,
  data: bytes | None = None,
  ) -> requests.Response:
+ full_url = f"{self.url}{path}"
  response: requests.Response = requests.put(
-f"{self.url}{path}",
+full_url,
  params=params,
  headers=headers,
  json=json,
  data=data,
  auth=self.auth,
  timeout=TIMEOUT,
+ verify=self.verifytls,
+ )
+ gs_logger.info(
+ "[GET] (%s) - %s",
+ response.status_code,
+ full_url,
+ extra={"response": response},
  )
  response.raise_for_status()
  return response
@@ -86,12 +112,20 @@ def delete(
  params: dict[str, str] | None = None,
  headers: dict[str, str] | None = None,
  ) -> requests.Response:
+ full_url = f"{self.url}{path}"
  response: requests.Response = requests.delete(
-f"{self.url}{path}",
+full_url,
  params=params,
  headers=headers,
  auth=self.auth,
  timeout=TIMEOUT,
+ verify=self.verifytls,
+ )
+ gs_logger.info(
+ "[GET] (%s) - %s",
+ response.status_code,
+ full_url,
+ extra={"response": response},
  )
  if response.status_code != 404:
  response.raise_for_status()

geoservercloud/services/restlogger.py

@@ -0,0 +1,12 @@
+import logging
+
+time_formatter = logging.Formatter(
+ "{asctime} - {name}:{levelname} - {message}",
+ style="{",
+ datefmt="%Y-%m-%d %H:%M",
+)
+stream_handler = logging.StreamHandler()
+stream_handler.setFormatter(time_formatter)
+gs_logger = logging.getLogger("GS Session")
+gs_logger.setLevel(logging.INFO)
+gs_logger.addHandler(stream_handler)