various updates

Author: barny

elmclient/_app.py

@@ -27,8 +27,10 @@ class _App( httpops.HttpOperations_Mixin ):
     reportablerest_baseurl = "publish"
     supports_reportable_rest = False
     reportable_rest_status = "Not supported by application"
+    majorVersion = None
+    version = None
 
-    def __init__(self, server, contextroot, jts=None):
+    def __init__(self, server, contextroot, *, jts=None):
         super().__init__()
         logger.info( f'Creating app {contextroot} {server=}' )
         self.contextroot = contextroot
@@ -46,14 +48,14 @@ def __init__(self, server, contextroot, jts=None):
     def retrieve_cm_service_provider_xml(self):
         cm_service_provider_uri = rdfxml.xmlrdf_get_resource_uri(self.rootservices_xml,
                                                                      self.cmServiceProviders)
-        rdf = self.execute_get_rdf_xml(cm_service_provider_uri)
+        rdf = self.execute_get_rdf_xml(cm_service_provider_uri, intent="Retrieve application CM Service Provider" )
         return rdf
 
     def retrieve_oslc_catalog_xml(self):
         oslccataloguri = rdfxml.xmlrdf_get_resource_uri(self.rootservices_xml, self.serviceproviders)
         if oslccataloguri is None:
             return None
-        return self.execute_get_rdf_xml(oslccataloguri)
+        return self.execute_get_rdf_xml(oslccataloguri, intent="Retrieve application OSLC Catalog (list of projects)")
 
     # get local headers
     def _get_headers(self, headers=None):
@@ -120,7 +122,7 @@ def _load_projects(self,include_archived=False,force=False):
         params = {}
         if include_archived:
             params['includeArchived'] = 'true'
-        self.project_areas_xml = self.execute_get_xml(uri, params=params)
+        self.project_areas_xml = self.execute_get_xml(uri, params=params, intent="Retrieve all project area definitions" )
         logger.debug( f"{self.project_areas_xml=}" )
         for projectel in rdfxml.xml_find_elements(self.project_areas_xml,".//jp06:project-area" ):
             logger.debug( f"{projectel=}" )
@@ -290,7 +292,7 @@ def user_nametouri_resolver(self, name, raiseifinvalid=True):
             user_uri = self.jts.baseurl+f"users/{name}"
             # check it using whoami
             try:
-                res = self.execute_get(user_uri)
+                res = self.execute_get(user_uri, intent="Try to retrieve User" )
             except requests.exceptions.HTTPError as e:
                 res = None
             if res:

elmclient/_ccm.py

@@ -187,7 +187,7 @@ def get_missing_uri_title( self,uri):
         id = None
         if uri.startswith( self.app.baseurl ):
             try:
-                resource_xml = self.execute_get_rdf_xml(reluri=uri)
+                resource_xml = self.execute_get_rdf_xml(reluri=uri, intent="Retrieve type definition to get its title" )
                 id = rdfxml.xmlrdf_get_resource_text(resource_xml, ".//dcterms:title")
             except ET.XMLSyntaxError as e:
                 logger.debug( f"Type {uri} doesn't exist (not XML)!" )
@@ -209,7 +209,7 @@ def get_missing_uri_title( self,uri):
     def type_name_from_uri(self, uri):
         if self.is_type_uri(uri):
             try:
-                resource_xml = self.execute_get_rdf_xml(reluri=uri)
+                resource_xml = self.execute_get_rdf_xml( reluri=uri, intent="Retrieve type definition to get its identifier" )
                 id = rdfxml.xmlrdf_get_resource_text(resource_xml, ".//dcterms:identifier")
             except requests.HTTPError as e:
                 if e.response.status_code==404 or e.response.status_code==406:
@@ -274,7 +274,7 @@ class _CCMApp(_app._App, _typesystem.No_Type_System_Mixin):
 
     def __init__(self, server, contextroot, jts=None):
         super().__init__(server, contextroot, jts=jts)
-        self.rootservices_xml = self.execute_get_xml(self.reluri('rootservices'))
+        self.rootservices_xml = self.execute_get_xml(self.reluri('rootservices'), intent="Retrieve CCM rootservices" )
         self.serviceproviders = 'oslc_cm:cmServiceProviders'
 
     def _get_headers(self, headers=None):
@@ -348,7 +348,7 @@ def process_represt_arguments( self, args, allapps ):
         if args.report:
             typestodo = []
             # get the schema, walk it building the tree of fields
-            schema_x = self.execute_get_xml(queryurl+"?metadata=schema").getroot()
+            schema_x = self.execute_get_xml(queryurl+"?metadata=schema", intent="Retrieve CCM Reportable REST schema" ).getroot()
 #            print( f"{schema_x.tag=}" )
 #            print( f"{schema_x=}" )
             el_x = rdfxml.xml_find_element( schema_x, "./xs:element" )

elmclient/_gcm.py

@@ -74,7 +74,7 @@ def __init__(self, name, project_uri, app, is_optin=False, singlemode=False,defa
         if not self.services_uri:
             raise Exception( "Service provide not found!" )
         if self.services_uri:
-            self.services_xml = self.app.execute_get_rdf_xml(self.services_uri)
+            self.services_xml = self.app.execute_get_rdf_xml( self.services_uri, intent="Retrieve project services xml" )
         else:
             self.services_xml = None
 
@@ -306,7 +306,7 @@ def _get_typeuri_rdf(self,uri):
         # strip off the fragment as it does nothing
         realuri = uri.rsplit( '#',1 )[0]
         if realuri not in self._gettypecache.keys():
-            self._gettypecache[realuri] = self.execute_get_rdf_xml(uri)
+            self._gettypecache[realuri] = self.execute_get_rdf_xml( uri, intent="Retrieve project/component type definition to cache it" )
         return self._gettypecache[realuri]
 
     # for OSLC query, given a type URI, return its name
@@ -386,7 +386,7 @@ class GCMApp(_app._App, oslcqueryapi._OSLCOperations_Mixin, _typesystem.Type_Sys
     def __init__(self, server, contextroot, jts=None):
         super().__init__(server, contextroot, jts=jts)
 
-        self.rootservices_xml = self.execute_get_xml(self.reluri('rootservices'))
+        self.rootservices_xml = self.execute_get_xml(self.reluri('rootservices'), intent="Retrieve GCM application rootservices" )
         self.serviceproviders = 'gc:globalConfigServiceProviders'
         self.default_query_resource = 'oslc_config:Configuration'
         # load all projects and components?
@@ -432,7 +432,7 @@ def get_query_capability_uris_from_xml(self,capabilitiesxml,context):
                     break
             if not found:
                 raise Exception( "No empty service provider found!" )
-            sx = self.execute_get_rdf_xml(spurl)
+            sx = self.execute_get_rdf_xml( spurl, intent="Retrieve project/component service provider definition to find query capability" )
             for qcx in rdfxml.xml_find_elements(sx,'.//oslc:queryBase/..'):
                 for qcrtx in rdfxml.xml_find_elements( qcx, 'oslc:resourceType'):
                     qcs[rdfxml.xmlrdf_get_resource_uri(qcrtx)] = rdfxml.xmlrdf_get_resource_uri(qcx, "oslc:queryBase")
@@ -443,7 +443,7 @@ def get_query_capability_uris_from_xml(self,capabilitiesxml,context):
 
     def check_valid_config_uri( self, uri, raise_exception=True ):
         try:
-            x = self.rootservices_xml = self.execute_get_xml(uri)
+            x = self.rootservices_xml = self.execute_get_xml( uri, intent="Check if configuration URL is valid (gets a response)" )
         except requests.HTTPError:
             if raiseException:
                 raise
@@ -475,7 +475,7 @@ def _load_types(self,force=False):
                 break
         if not found:
             raise Exception( "No empty service provider found!" )
-        sx = self.execute_get_rdf_xml(spurl)
+        sx = self.execute_get_rdf_xml( spurl, intent="Retrieve project/component service provider XML" )
 
         if sx:
             shapes_to_load = rdfxml.xml_find_elements(sx, './/oslc:resourceShape' )
@@ -655,7 +655,7 @@ def _get_typeuri_rdf(self,uri):
         # strip off the fragment as it does nothing
         realuri = uri.rsplit( '#',1 )[0]
         if realuri not in self._gettypecache.keys():
-            self._gettypecache[realuri] = self.execute_get_rdf_xml(uri)
+            self._gettypecache[realuri] = self.execute_get_rdf_xml(uri,intent="Retrieve type definition" )
         return self._gettypecache[realuri]
 
     # given a type URI, return its name

elmclient/_project.py

@@ -68,7 +68,7 @@ def _get_typeuri_rdf(self,uri):
             logger.info( f"Retrieving {uri}" )
             logger.info( utils.callers() )
             try:
-                self._gettypecache[realuri] = self.execute_get_rdf_xml(uri) if uri.startswith( "https://") else None
+                self._gettypecache[realuri] = self.execute_get_rdf_xml(uri, intent="Retrieve type definition") if uri.startswith( "https://") else None
                 logger.info( f"Retrieved:" )
             except ET.XMLSyntaxError:
                  self._gettypecache[realuri] = None
@@ -113,7 +113,7 @@ def get_services_xml(self, headers=None, force=False):
         logger.info( f"get_services_xml {self.name=} {self.project_uri=} {self=} {self.services_uri=}" )
         if force or self.services_xml is None:
             if self.services_uri:
-                self.services_xml = self.execute_get_rdf_xml(self.services_uri, headers=headers)
+                self.services_xml = self.execute_get_rdf_xml(self.services_uri, headers=headers, intent="Retrieve project's services XML")
                 logger.info( f"{self.services_uri=}" )
             elif self.component_project:
                 logger.debug( f"component sx not retrieved - need a config" )
@@ -207,7 +207,7 @@ def set_local_config(self, name_or_uri, global_config_uri=None):
         # for a component, setting the config is when we can load the services xml!
         if self.component_project:
             # retrieve the services.xml in the current config!
-            self.services_xml = self.execute_get_rdf_xml(self.component_project.services_uri)
+            self.services_xml = self.execute_get_rdf_xml(self.component_project.services_uri, intent="Retrieve project's services.xml")
 
     def _load_types(self,force=False):
         logger.info( f"{self=}" )

elmclient/_qm.py

@@ -52,24 +52,24 @@ def load_components_and_configurations(self,force=False):
         if not self.is_optin:
             logger.debug( f"{self.is_optin=}" )
             # get the default configuration
-            projx = self.execute_get_xml(self.reluri('rm-projects/' + self.iid))
+            projx = self.execute_get_xml( self.reluri( 'rm-projects/' + self.iid ), intent="Retrieve the project definition (opt-out)" )
             compsu = rdfxml.xmlrdf_get_resource_text( projx, './/jp06:components' )
-            compsx = self.execute_get_xml(compsu)
+            compsx = self.execute_get_xml(compsu, intent="Retrieve the component definition (opt-out)" )
             defaultcompu = rdfxml.xmlrdf_get_resource_uri( compsx, './/oslc_config:component' )
-
+            
             # register the only component
             ncomps += 1
             self._components[defaultcompu] = {'name': self.name, 'configurations': {}}
             thisconfu = defaultcompu+"/configurations"
-            configs = self.execute_get_json(thisconfu)
+            configs = self.execute_get_json( thisconfu, intent="Retrieve all configurations (opt-out)" )
             configdetails = configs[defaultcompu+"/configurations"]
             if type(configs[thisconfu]["http://www.w3.org/2000/01/rdf-schema#member"])==dict:
                 confs = [configs[thisconfu]["http://www.w3.org/2000/01/rdf-schema#member"]]
             else:
                 confs = configs[thisconfu]["http://www.w3.org/2000/01/rdf-schema#member"]
             for aconf in confs:
                 confu = aconf['value']
-                confx = self.execute_get_xml(confu)
+                confx = self.execute_get_xml( confu, intent="Retrieve configuration definition (opt-out)" )
                 conftitle = rdfxml.xmlrdf_get_resource_text(confx,'.//dcterms:title')
                 conftype = 'Stream' if 'stream' in confu else 'Baseline'
                 self._components[defaultcompu]['configurations'][confu] = {'name': conftitle, 'conftype': conftype, 'confXml': confx}
@@ -85,7 +85,7 @@ def load_components_and_configurations(self,force=False):
             #    <dcterms:title rdf:datatype="http://www.w3.org/2001/XMLSchema#string">View Definition Query Capability</dcterms:title>
             # </oslc:QueryCapability>
 
-            px = self.execute_get_xml(self.project_uri)
+            px = self.execute_get_xml( self.project_uri, intent="Retrieve project definition" )
 
             sx = self.get_services_xml()
             assert sx is not None, "sx is None"
@@ -94,10 +94,10 @@ def load_components_and_configurations(self,force=False):
 
             ncomps += 1
             self._components[compuri] = {'name': self.name, 'configurations': {}}
-            configs = self.execute_get_xml(compuri+"/configurations")
+            configs = self.execute_get_xml( compuri+"/configurations", intent="Retrieve all project/component configurations (singlemode)" )
             for conf in rdfxml.xml_find_elements(configs,'.//rdfs:member'):
                 confu = rdfxml.xmlrdf_get_resource_uri(conf)
-                thisconfx = self.execute_get_xml(confu)
+                thisconfx = self.execute_get_xml( confu, intent="Retrieve a configuration definition (singlemode)" )
                 conftitle= rdfxml.xmlrdf_get_resource_text(thisconfx,'.//dcterms:title')
                 # e.g. http://open-services.net/ns/config#Stream
                 isstr = rdfxml.xml_find_element( thisconfx,'.//oslc_config:Stream' )
@@ -124,7 +124,7 @@ def load_components_and_configurations(self,force=False):
             components_uri = rdfxml.xmlrdf_get_resource_uri(cmsp_xml, './/rdf:Description/rdf:type[@rdf:resource="http://open-services.net/ns/core#QueryCapability"]/../oslc:resourceType[@rdf:resource="http://open-services.net/ns/config#Component"]/../oslc:queryBase')
             logger.info( f"{components_uri=}" )
             # get all components
-            crx = self.execute_get_xml(components_uri)
+            crx = self.execute_get_xml( components_uri, intent="Retrieve component definition" )
 
 #      <oslc_config:Component rdf:about="https://jazz.ibm.com:9443/qm/oslc_config/resources/com.ibm.team.vvc.Component/_iw4s4EB3Eeus6Zk4qsm_Cw">
 #        <dcterms:title rdf:parseType="Literal">SGC Agile</dcterms:title>
@@ -146,13 +146,13 @@ def load_components_and_configurations(self,force=False):
                 self._components[compu] = {'name': comptitle, 'configurations': {}}
                 ncomps += 1
                 confu = rdfxml.xmlrdf_get_resource_uri(component_el, './/oslc_config:configurations')
-                configs_xml = self.execute_get_rdf_xml( confu )
+                configs_xml = self.execute_get_rdf_xml( confu, intent="Retrieve all project/component configuration definitions" )
                 # Each config:     <ldp:contains rdf:resource="https://jazz.ibm.com:9443/qm/oslc_config/resources/com.ibm.team.vvc.Configuration/_qT1EcEB4Eeus6Zk4qsm_Cw"/>
 
                 for confmemberx in rdfxml.xml_find_elements(configs_xml, './/ldp:contains'):
                     thisconfu = rdfxml.xmlrdf_get_resource_uri( confmemberx )
                     try:
-                        thisconfx = self.execute_get_rdf_xml(thisconfu)
+                        thisconfx = self.execute_get_rdf_xml( thisconfu, intent="Retrieve a configuration definition" )
                         conftitle = rdfxml.xmlrdf_get_resource_text(thisconfx, './/dcterms:title')
                         conftype = rdfxml.xmlrdf_get_resource_uri(thisconfx, './/rdf:type')
                         logger.info( f"Found config {conftitle} {conftype} {thisconfu}" )
@@ -267,7 +267,7 @@ def type_name_from_uri(self, uri):
                     id = match.group(1)
                 else:
                     # retrieve the definition
-                    resource_xml = self.execute_get_rdf_xml(reluri=uri)
+                    resource_xml = self.execute_get_rdf_xml( reluri=uri, intent="Retrieve type definition to get its name")
                     # check for a rdf label (used for links, maybe other things)
                     id = rdfxml.xmlrdf_get_resource_text(resource_xml,".//rdf:Property/rdfs:label") or rdfxml.xmlrdf_get_resource_text(resource_xml,".//oslc:ResourceShape/dcterms:title") or rdfxml.xmlrdf_get_resource_text(resource_xml,f'.//rdf:Description[@rdf:about="{uri}"]/rdfs:label')
                     if id is None:
@@ -290,7 +290,7 @@ def is_resource_uri(self, uri):
     # for OSLC query, given a resource URI, return the requirement dcterms:identifier
     def resource_id_from_uri(self, uri):
         if self.is_resource_uri(uri):
-            resource_xml = self.execute_get_rdf_xml(reluri=uri)
+            resource_xml = self.execute_get_rdf_xml(reluri=uri, intent="Retrieve resource dcterms:identifier")
             id = rdfxml.xmlrdf_get_resource_text(resource_xml, ".//dcterms:identifier")
             return id
         raise Exception(f"Bad resource uri {uri}")
@@ -381,12 +381,12 @@ class _QMApp(_app._App, oslcqueryapi._OSLCOperations_Mixin, _typesystem.Type_Sys
 
     def __init__(self, server, contextroot, jts=None):
         super().__init__(server, contextroot, jts=jts)
-        self.rootservices_xml = self.execute_get_xml(self.reluri('rootservices'))
+        self.rootservices_xml = self.execute_get_xml(self.reluri('rootservices'), intent="Retrieve QM application rootservices")
         self.serviceproviders = 'oslc_qm_10:qmServiceProviders'
         self.default_query_resource = "oslc_config:Configuration"
 
-        self.version = rdfxml.xmlrdf_get_resource_text(self.rootservices_xml,'.//oslc_rm_10:version')
-        self.majorversion = rdfxml.xmlrdf_get_resource_text(self.rootservices_xml,'.//oslc_rm_10:majorVersion')
+        self.version = rdfxml.xmlrdf_get_resource_text(self.rootservices_xml,'.//rqm:version')
+        self.majorversion = rdfxml.xmlrdf_get_resource_text(self.rootservices_xml,'.//rqm:majorVersion')
         logger.info( f"Versions {self.majorversion} {self.version}" )
 
     def _get_headers(self, headers=None):
@@ -533,7 +533,7 @@ def process_represt_arguments( self, args, allapps ):
         if args.report:
             typestodo = []
             # get the schema, walk it building the tree of fields
-            schema_x = self.execute_get_xml(queryurl+"?metadata=schema").getroot()
+            schema_x = self.execute_get_xml(queryurl+"?metadata=schema", intent="Retrieve Reportable REST schema").getroot()
 #            print( f"{schema_x.tag=}" )
 #            print( f"{schema_x=}" )
             el_x = rdfxml.xml_find_element( schema_x, "./xs:element" )