Merge pull request #107 from GeekMasher/depgraph-server

Depgraph server

Author: GeekMasher

src/ghastoolkit/octokit/clearlydefined.py

@@ -62,7 +62,10 @@ def getLicenses(self, dependency: Dependency) -> list[str]:
                 curlicense = curation.get("licensed", {}).get("declared")
                 if curlicense:
                     licenses.add(curlicense)
-        except:
+        except KeyboardInterrupt:
+            raise Exception("Keyboard Interrupt")
+        except Exception as err:
             logger.warning(f"Error getting curation data :: {dependency}")
+            logger.warning(f"Error :: {err}")
 
         return list(licenses)

src/ghastoolkit/octokit/dependencygraph.py

@@ -3,6 +3,8 @@
 from typing import Any, Dict
 import urllib.parse
 
+from semantic_version import Version
+
 from ghastoolkit.octokit.github import GitHub, Repository
 from ghastoolkit.supplychain.advisories import Advisory
 from ghastoolkit.supplychain.dependencyalert import DependencyAlert
@@ -53,7 +55,24 @@ def getOrganizationDependencies(self) -> Dict[Repository, Dependencies]:
 
     def getDependencies(self) -> Dependencies:
         """Get Dependencies."""
-        deps = self.getDependenciesSbom()
+        if GitHub.isEnterpriseServer():
+            if not self.enable_clearlydefined:
+                logger.warning(
+                    "Enterprise Server does not support licensing information"
+                )
+            # enterprise: 3.8+ use SBOM API
+            if GitHub.server_version >= Version("3.9.0"):
+                logger.info("Using SBOM API to resolve dependencies (GHES 3.9+)")
+                deps = self.getDependenciesSbom()
+            # enterprise: 3.7+ use GraphQL API
+            elif GitHub.server_version >= Version("3.6.0"):
+                logger.warning("Using GraphQL API to resolve dependencies (GHES 3.6+)")
+                deps = self.getDependenciesGraphQL()
+            else:
+                raise Exception("Enterprise Server version must be >= 3.6.0")
+        else:
+            # cloud: download SBOM
+            deps = self.getDependenciesSbom()
 
         if self.enable_graphql:
             logger.debug("Enabled GraphQL Dependencies")
@@ -62,7 +81,7 @@ def getDependencies(self) -> Dependencies:
             deps.updateDependencies(graph_deps)
 
         if self.enable_clearlydefined:
-            logger.debug("Applying ClearlyDefined on dependencies")
+            logger.info("Using ClearlyDefined API to resolve dependency licenses")
             deps.applyClearlyDefined()
         return deps
 
@@ -141,6 +160,10 @@ def getDependenciesGraphQL(self) -> Dependencies:
 
     def getDependenciesInPR(self, base: str, head: str) -> Dependencies:
         """Get all the dependencies from a Pull Request."""
+
+        if GitHub.isEnterpriseServer() and GitHub.server_version < Version("3.6.0"):
+            raise Exception("Enterprise Server version must be >= 3.6")
+
         dependencies = Dependencies()
         base = urllib.parse.quote(base, safe="")
         head = urllib.parse.quote(head, safe="")

src/ghastoolkit/octokit/github.py

@@ -5,9 +5,11 @@
 import tempfile
 import subprocess
 from dataclasses import dataclass
-from typing import Optional, Tuple, Union
+from typing import Dict, Optional, Tuple, Union
 from urllib.parse import urlparse
 
+from semantic_version import Version
+
 
 logger = logging.getLogger("ghastoolkit.octokit.github")
 
@@ -252,6 +254,7 @@ class GitHub:
     """GraphQL API URL"""
 
     enterprise: Optional[str] = None
+    server_version: Optional[Version] = None
 
     github_app: bool = False
     """GitHub App setting"""
@@ -288,6 +291,10 @@ def init(
             GitHub.instance = instance
             GitHub.api_rest, GitHub.api_graphql = GitHub.parseInstance(instance)
 
+            if GitHub.isEnterpriseServer():
+                # Get the server version
+                GitHub.getMetaInformation()
+
         GitHub.enterprise = enterprise
 
         return
@@ -302,11 +309,29 @@ def parseInstance(instance: str) -> Tuple[str, str]:
             api = url.scheme + "://api." + url.netloc
             return (api, f"{api}/graphql")
         # GitHub Ent Server
-        api = url.scheme + "://" + url.netloc + "/api/v3"
+        api = url.scheme + "://" + url.netloc + "/api"
 
-        return (api, f"{api}/graphql")
+        return (f"{api}/v3", f"{api}/graphql")
+
+    @staticmethod
+    def isEnterpriseServer() -> bool:
+        """Is the GitHub instance an Enterprise Server."""
+        return GitHub.instance != "https://github.com"
 
     @staticmethod
     def display() -> str:
         """Display the GitHub Settings."""
         return f"GitHub('{GitHub.repository.display()}', '{GitHub.instance}')"
+
+    @staticmethod
+    def getMetaInformation() -> Dict:
+        """Get the GitHub Meta Information."""
+        from ghastoolkit.octokit.octokit import RestRequest
+
+        response = RestRequest().session.get(f"{GitHub.api_rest}/meta")
+
+        if response.headers.get("X-GitHub-Enterprise-Version"):
+            version = response.headers.get("X-GitHub-Enterprise-Version")
+            GitHub.server_version = Version(version)
+
+        return response.json()

src/ghastoolkit/octokit/octokit.py

@@ -134,7 +134,7 @@ def wrap(self, *args, **kwargs):
                 result = rest.get(url, parameters=params, authenticated=authenticated)
 
                 if response:
-                    return func(self, responce=result, **kwargs)
+                    return func(self, response=result, **kwargs)
 
                 # TODO: runtime type checking
 
@@ -203,29 +203,29 @@ def get(
         while True:
             params["page"] = page
 
-            responce = self.session.get(url, params=params)
-            responce_json = responce.json()
+            response = self.session.get(url, params=params)
+            response_json = response.json()
 
-            if responce.status_code != expected:
+            if response.status_code != expected:
                 if display_errors:
-                    logger.error(f"Error code from server :: {responce.status_code}")
-                    logger.error(f"Content :: {responce_json}")
+                    logger.error(f"Error code from server :: {response.status_code}")
+                    logger.error(f"Content :: {response_json}")
 
-                known_error = __OCTOKIT_ERRORS__.get(responce.status_code)
+                known_error = __OCTOKIT_ERRORS__.get(response.status_code)
                 if known_error:
                     raise Exception(known_error)
                 raise Exception("REST Request failed :: non-expected server error")
 
-            if isinstance(responce_json, dict) and responce_json.get("errors"):
-                logger.error(responce_json.get("message"))
+            if isinstance(response_json, dict) and response_json.get("errors"):
+                logger.error(response_json.get("message"))
                 raise Exception("REST Request failed :: error from server")
 
-            if isinstance(responce_json, dict):
-                return responce_json
+            if isinstance(response_json, dict):
+                return response_json
 
-            result.extend(responce_json)
+            result.extend(response_json)
             # if the page is not full, we must have hit the end
-            if len(responce_json) < RestRequest.PER_PAGE:
+            if len(response_json) < RestRequest.PER_PAGE:
                 break
 
             page += 1

tests/test_github.py

@@ -28,7 +28,7 @@ def test_server(self):
         self.assertEqual(GitHub.instance, "https://github.geekmasher.dev")
         self.assertEqual(GitHub.api_rest, "https://github.geekmasher.dev/api/v3")
         self.assertEqual(
-            GitHub.api_graphql, "https://github.geekmasher.dev/api/v3/graphql"
+            GitHub.api_graphql, "https://github.geekmasher.dev/api/graphql"
         )
 
     def test_parseReference(self):