|
|
@@ -0,0 +1,141 @@
|
|
|
+import os
|
|
|
+import re
|
|
|
+import requests
|
|
|
+from itertools import groupby
|
|
|
+from github import Github
|
|
|
+from github.GithubException import GithubException
|
|
|
+
|
|
|
+repos_URL = {
|
|
|
+ "stable": "netdata/netdata",
|
|
|
+ "nightly": "netdata/netdata-nightlies"
|
|
|
+}
|
|
|
+
|
|
|
+GH_TOKEN = os.getenv("GH_TOKEN")
|
|
|
+if GH_TOKEN is None or GH_TOKEN != "":
|
|
|
+ print("Token is not defined or empty, continuing with limitation on requests per sec towards Github API")
|
|
|
+
|
|
|
+
|
|
|
+def identify_channel(_version):
|
|
|
+ nightly_pattern = r'v(\d+)\.(\d+)\.(\d+)-(\d+)-nightly'
|
|
|
+ stable_pattern = r'v(\d+)\.(\d+)\.(\d+)'
|
|
|
+ if re.match(nightly_pattern, _version):
|
|
|
+ _channel = "nightly"
|
|
|
+ _pattern = nightly_pattern
|
|
|
+ elif re.match(stable_pattern, _version):
|
|
|
+ _channel = "stable"
|
|
|
+ _pattern = stable_pattern
|
|
|
+ else:
|
|
|
+ print("Invalid version format.")
|
|
|
+ return None
|
|
|
+ return _channel, _pattern
|
|
|
+
|
|
|
+
|
|
|
+def padded_version(item):
|
|
|
+ key_value = '10000'
|
|
|
+ for value in item[1:]:
|
|
|
+ key_value += f'{value:05}'
|
|
|
+ return int(key_value)
|
|
|
+
|
|
|
+
|
|
|
+def extract_version(title):
|
|
|
+ if identify_channel(title):
|
|
|
+ _, _pattern = identify_channel(title)
|
|
|
+ try:
|
|
|
+ match = re.match(_pattern, title)
|
|
|
+ if match:
|
|
|
+ return tuple(map(int, match.groups()))
|
|
|
+ except Exception as e:
|
|
|
+ print(f"Unexpected error: {e}")
|
|
|
+ return None
|
|
|
+
|
|
|
+
|
|
|
+def get_release_path_and_filename(_version):
|
|
|
+ nightly_pattern = r'v(\d+)\.(\d+)\.(\d+)-(\d+)-nightly'
|
|
|
+ stable_pattern = r'v(\d+)\.(\d+)\.(\d+)'
|
|
|
+ if match := re.match(nightly_pattern, _version):
|
|
|
+ msb = match.group(1)
|
|
|
+ _path = "nightly"
|
|
|
+ _filename = f"v{msb}"
|
|
|
+ elif match := re.match(stable_pattern, _version):
|
|
|
+ msb = match.group(1)
|
|
|
+ _path = "stable"
|
|
|
+ _filename = f"v{msb}"
|
|
|
+ else:
|
|
|
+ print("Invalid version format.")
|
|
|
+ exit(1)
|
|
|
+ return (_path, _filename)
|
|
|
+
|
|
|
+
|
|
|
+def compare_version_with_remote(version):
|
|
|
+ """
|
|
|
+ If the version = fun (version) you need to update the version in the
|
|
|
+ remote. If the version remote doesn't exist, returns the version
|
|
|
+ :param channel: any version of the agent
|
|
|
+ :return: the greater from version and version remote.
|
|
|
+ """
|
|
|
+
|
|
|
+ prefix = "https://packages.netdata.cloud/releases"
|
|
|
+ path, filename = get_release_path_and_filename(version)
|
|
|
+
|
|
|
+ remote_url = f"{prefix}/{path}/{filename}"
|
|
|
+ response = requests.get(remote_url)
|
|
|
+
|
|
|
+ if response.status_code == 200:
|
|
|
+ version_remote = response.text.rstrip()
|
|
|
+
|
|
|
+ version_components = extract_version(version)
|
|
|
+ remote_version_components = extract_version(version_remote)
|
|
|
+
|
|
|
+ absolute_version = padded_version(version_components)
|
|
|
+ absolute_remote_version = padded_version(remote_version_components)
|
|
|
+
|
|
|
+ if absolute_version > absolute_remote_version:
|
|
|
+ print(f"Version in the remote: {version_remote}, is older than the current: {version}, I need to update")
|
|
|
+ return (version)
|
|
|
+ else:
|
|
|
+ print(f"Version in the remote: {version_remote}, is newer than the current: {version}, no action needed")
|
|
|
+ return (None)
|
|
|
+ else:
|
|
|
+ # Remote version not found
|
|
|
+ print(f"Version in the remote not found, updating the predefined latest path with the version: {version}")
|
|
|
+ return (version)
|
|
|
+
|
|
|
+
|
|
|
+def sort_and_grouby_major_agents_of_channel(channel):
|
|
|
+ """
|
|
|
+ Fetches the GH API and read either netdata/netdata or netdata/netdata-nightlies repo. It fetches all of their
|
|
|
+ releases implements a grouping by their major release number.
|
|
|
+ Every k,v in this dictionary is in the form; "vX": [descending ordered list of Agents in this major release].
|
|
|
+ :param channel: "nightly" or "stable"
|
|
|
+ :return: None or dict() with the Agents grouped by major version # (vX)
|
|
|
+ """
|
|
|
+ try:
|
|
|
+ G = Github(GH_TOKEN)
|
|
|
+ repo = G.get_repo(repos_URL[channel])
|
|
|
+ releases = repo.get_releases()
|
|
|
+ except GithubException as e:
|
|
|
+ print(f"GitHub API request failed: {e}")
|
|
|
+ return None
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ print(f"An unexpected error occurred: {e}")
|
|
|
+ return None
|
|
|
+
|
|
|
+ extracted_titles = [extract_version(item.title) for item in releases if
|
|
|
+ extract_version(item.title) is not None]
|
|
|
+ # Necessary sorting for implement the group by
|
|
|
+ extracted_titles.sort(key=lambda x: x[0])
|
|
|
+ # Group titles by major version
|
|
|
+ grouped_by_major = {major: list(group) for major, group in groupby(extracted_titles, key=lambda x: x[0])}
|
|
|
+ sorted_grouped_by_major = {}
|
|
|
+ for key, values in grouped_by_major.items():
|
|
|
+ sorted_values = sorted(values, key=padded_version, reverse=True)
|
|
|
+ sorted_grouped_by_major[key] = sorted_values
|
|
|
+ # Transform them in the correct form
|
|
|
+ if channel == "stable":
|
|
|
+ result_dict = {f"v{key}": [f"v{a}.{b}.{c}" for a, b, c in values] for key, values in
|
|
|
+ sorted_grouped_by_major.items()}
|
|
|
+ else:
|
|
|
+ result_dict = {f"v{key}": [f"v{a}.{b}.{c}-{d}-nightly" for a, b, c, d in values] for key, values in
|
|
|
+ sorted_grouped_by_major.items()}
|
|
|
+ return result_dict
|
Tasos Katsoulas