def get_config_directory(
*, project_name: str,
project_version: str) -> str: # pragma: no cover ## Not relevant
"""
Provides the location of the configuration directory.
"""
# pylint: disable=too-many-branches
env_var_helper = EnvironmentVariableHelper()
directory_helper = DirectoryHelper()
if env_var_helper.set_name("PYFUNCEBLE_CONFIG_DIR").exists():
config_directory = env_var_helper.get_value()
elif env_var_helper.set_name("PYFUNCEBLE_OUTPUT_DIR").exists():
config_directory = env_var_helper.get_value()
elif (VersionUtility(project_version).is_cloned()
or env_var_helper.set_name("TRAVIS_BUILD_DIR").exists()
or env_var_helper.set_name("CI_PROJECT_DIR").exists()
and env_var_helper.set_name("GITLAB_CI").exists()):
config_directory = directory_helper.get_current(with_end_sep=True)
else:
if PlatformUtility.is_unix():
config_dir_path = os.path.expanduser(os.path.join("~", ".config"))
if directory_helper.set_path(config_dir_path).exists():
config_directory = config_dir_path
elif directory_helper.set_path(os.path.expanduser("~")).exists():
config_directory = directory_helper.join_path(".")
else:
config_directory = directory_helper.get_current(
with_end_sep=True)
elif PlatformUtility.is_windows():
if env_var_helper.set_name("APPDATA").exists():
config_directory = env_var_helper.get_value()
else:
config_directory = directory_helper.get_current(
with_end_sep=True)
else:
config_directory = directory_helper.get_current(with_end_sep=True)
if not config_directory.endswith(os.sep):
config_directory += os.sep
config_directory += project_name + os.sep
if not directory_helper.set_path(config_directory).exists():
directory_helper.create()
if not config_directory.endswith(os.sep):
config_directory += os.sep
return config_directory
def guess_and_set_min_level(self) -> "Logger":
"""
Tries to guess the min level from the configuration.
"""
env_vars = ["PYFUNCEBLE_DEBUG_LVL", "PYFUNCEBLE_LOGGING_LVL"]
env_var_helper = EnvironmentVariableHelper()
env_var_found = False
for env_var in env_vars:
if env_var_helper.set_name(env_var).exists():
self.min_level = env_var_helper.get_value()
env_var_found = True
break
if not env_var_found:
if PyFunceble.storage.CONFIGURATION:
# pylint: disable=protected-access
self.min_level = logging._nameToLevel[
PyFunceble.storage.CONFIGURATION.debug.level.upper()
]
else:
self.min_level = self.STD_MIN_LEVEL
def __init__(self, save: bool = False, end: bool = False) -> None:
self.info_manager = InfoManager()
git_name = EnvironmentVariableHelper("GIT_NAME")
git_email = EnvironmentVariableHelper("GIT_EMAIL")
if git_email.exists() and "funilrys" in git_email.get_value():
git_name.set_value(dead_hosts.launcher.defaults.envs.GIT_NAME)
git_email.set_value(dead_hosts.launcher.defaults.envs.GIT_EMAIL)
EnvironmentVariableHelper("PYFUNCEBLE_OUTPUT_LOCATION").set_value(
self.info_manager.WORKSPACE_DIR)
EnvironmentVariableHelper("PYFUNCEBLE_CONFIG_DIR").set_value(
self.info_manager.PYFUNCEBLE_CONFIG_DIR)
self.authorization_handler = Authorization(self.info_manager)
self.origin_file = FileHelper(
os.path.join(
self.info_manager.WORKSPACE_DIR,
dead_hosts.launcher.defaults.paths.ORIGIN_FILENAME,
))
self.output_file = FileHelper(
os.path.join(
self.info_manager.WORKSPACE_DIR,
dead_hosts.launcher.defaults.paths.OUTPUT_FILENAME,
))
logging.info("Origin file: %r", self.origin_file.path)
logging.info("Output file: %r", self.output_file.path)
if not end and not save:
logging.info("Checking authorization to run.")
if self.authorization_handler.is_test_authorized():
execute_all_updater(self.info_manager)
PyFunceble.facility.ConfigLoader.start()
self.fetch_file_to_test()
self.run_test()
else:
logging.info(
"Not authorized to run a test until %r (current time) > %r",
datetime.now(),
self.authorization_handler.next_authorization_time,
)
sys.exit(0)
elif save:
self.run_autosave()
else:
self.run_end()
def guess_and_set_token(self) -> "GitLabCI":
"""
Tries to guess and set the token.
"""
environment_var = EnvironmentVariableHelper("GL_TOKEN")
if environment_var.exists():
self.token = environment_var.get_value()
return self
def guess_and_set_git_name(self) -> "ContinuousIntegrationBase":
"""
Tries to guess and set the Git Name.
"""
environment_var = EnvironmentVariableHelper("GIT_NAME")
if environment_var.exists():
self.git_name = environment_var.get_value()
return self
def guess_and_set_git_email(self) -> "ContinuousIntegrationBase":
"""
Tries to guess and set the Git Email.
"""
environment_var = EnvironmentVariableHelper("GIT_EMAIL")
if environment_var.exists():
self.git_email = environment_var.get_value()
return self
def __init__(
self,
administration: Administration,
) -> None:
self.administration = administration
self.system_launcher = UHBPyFuncebleSystemLauncher(
administration=self.administration)
env_helper = EnvironmentVariableHelper("GITHUB_TOKEN")
self.kill_switch = EnvironmentVariableHelper("UHB_GH_KILL_SWITCH")
self.github_api = Github(env_helper.get_value(default=None))
def guess_and_set_git_branch(self) -> "ContinuousIntegrationBase":
"""
Tries to guess and set the Git Branch.
"""
environment_var = EnvironmentVariableHelper("GIT_BRANCH")
if environment_var.exists():
self.git_branch = environment_var.get_value()
elif PyFunceble.facility.ConfigLoader.is_already_loaded():
self.git_branch = PyFunceble.storage.CONFIGURATION.cli_testing.ci.branch
else:
self.git_branch = self.STD_GIT_BRANCH
return self
def start(self, *, ignore_cli: bool = True) -> "CredentialLoader":
"""
Starts the loading of the credential.
:param ignore_cli:
Ignore questions to end-user.
"""
if not isinstance(self.credential, CredentialBase) and self.authorized:
# We directly share the credential object into the DBSession object.
# This will let us use the DBSession without having to think about
# any other headache.
self.credential = (PyFunceble.cli.factory.DBSession.credential
) = self.DB_TYPE2OBJ[self.db_type]()
env_var_helper = EnvironmentVariableHelper(
env_file_path=self.credential.get_dot_env_file())
for cred_var, env_var in self.credential.VAR2ENV.items():
if env_var_helper.set_name(env_var).exists():
self.set_credential_var(cred_var,
env_var_helper.get_value())
else:
from_file = env_var_helper.get_value_from_env_file()
if from_file:
self.set_credential_var(cred_var, from_file)
elif not ignore_cli:
self.set_credential_var(
cred_var,
self.ask_for_info(
cred_var,
getattr(self.credential,
f"STD_{cred_var.upper()}"),
),
)
else:
self.set_credential_var(
cred_var,
getattr(self.credential,
f"STD_{cred_var.upper()}"),
)
env_var_helper.set_value_in_env_file(
str(getattr(self.credential, cred_var)))
return self
def get_output_directory() -> str: # pragma: no cover ## Not relevant
"""
Provides the location of the output directory.
"""
env_var_helper = EnvironmentVariableHelper()
directory_helper = DirectoryHelper()
if env_var_helper.set_name("PYFUNCEBLE_OUTPUT_LOCATION").exists():
output_directory = env_var_helper.get_value()
else:
output_directory = directory_helper.get_current(with_end_sep=True)
if not output_directory.endswith(os.sep):
output_directory += os.sep
return output_directory
class TestEnvironmentVariableHelper(unittest.TestCase):
"""
Tests of our environment variable helper.
"""
def setUp(self) -> None:
"""
Setups everything needed for the tests.
"""
self.helper = EnvironmentVariableHelper()
self.test_name = "PYFUNCEBLE_TESTING"
self.temp_env_file = tempfile.NamedTemporaryFile("w", delete=False)
def tearDown(self) -> None:
"""
Destroys everything needed for the tests.
"""
self.temp_env_file.close()
os.remove(self.temp_env_file.name)
del self.temp_env_file
del self.test_name
del self.helper
def test_set_name_return(self) -> None:
"""
Tests the response from the method which let us set the name to work
with.
"""
actual = self.helper.set_name(self.test_name)
self.assertIsInstance(actual, EnvironmentVariableHelper)
def test_set_name_method(self) -> None:
"""
Tests the method which let us set the name to work with.
"""
given = self.test_name
expected = given
self.helper.set_name(given)
actual = self.helper.name
self.assertEqual(expected, actual)
def test_set_name_attribute(self) -> None:
"""
Tests the method which let us overwrite the `name` attribute.
"""
given = self.test_name
expected = given
self.helper.name = given
actual = self.helper.name
self.assertEqual(expected, actual)
def test_set_name_through_init(self) -> None:
"""
Tests the overwritting of the name to work with through the class
constructor.
"""
given = self.test_name
expected = given
helper = EnvironmentVariableHelper(given)
actual = helper.name
self.assertEqual(expected, actual)
def test_set_env_file_path_return(self) -> None:
"""
Tests the response from the method which let us set the path to the
dot env file to work with.
"""
actual = self.helper.set_env_file_path(self.temp_env_file.name)
self.assertIsInstance(actual, EnvironmentVariableHelper)
def test_set_env_file_path_method(self) -> None:
"""
Tests the method which let us set the path to the dotenv file to work with.
"""
given = self.temp_env_file.name
expected = given
self.helper.set_env_file_path(given)
actual = self.helper.env_file_path
self.assertEqual(expected, actual)
def test_set_env_file_path_attribute(self) -> None:
"""
Tests the method which let us overwrite the `env_file_path` attribute.
"""
given = self.temp_env_file.name
expected = given
self.helper.env_file_path = given
actual = self.helper.env_file_path
self.assertEqual(expected, actual)
def test_set_env_file_path_through_init(self) -> None:
"""
Tests the overwritting of the dotenv file to work with through the class
constructor.
"""
given = self.temp_env_file.name
expected = given
helper = EnvironmentVariableHelper(env_file_path=given)
actual = helper.env_file_path
self.assertEqual(expected, actual)
def test_set_name_not_str(self) -> None:
"""
Tests the method which let us set the name of the environment variable
to work with for the case that the given name is not a string.
"""
given = ["Hello", "World"]
self.assertRaises(TypeError, lambda: self.helper.set_name(given))
def test_set_env_file_path_not_str(self) -> None:
"""
Tests the method which let us set the path to the dotenv file to work
with for the case that the given path is not a string.
"""
given = ["Hello", "World"]
self.assertRaises(TypeError,
lambda: self.helper.set_env_file_path(given))
def test_exists(self) -> None:
"""
Tests of the method which let us test if an environment variable exists.
"""
expected = False
actual = self.helper.set_name(self.test_name).exists()
self.assertEqual(expected, actual)
os.environ[self.test_name] = "This is a test."
expected = True
actual = self.helper.exists()
self.assertEqual(expected, actual)
del os.environ[self.test_name]
def test_get_value(self) -> None:
"""
Tests of the method which let us get the value of an environment
variable.
"""
expected = False
actual = self.helper.set_name(self.test_name).exists()
self.assertEqual(expected, actual)
expected = "Hello"
actual = self.helper.get_value(default="Hello")
self.assertEqual(expected, actual)
expected = "This is a test."
os.environ[self.test_name] = "This is a test."
actual = self.helper.get_value(default="Hello")
self.assertEqual(expected, actual)
del os.environ[self.test_name]
def test_get_value_from_file(self) -> None:
"""
Tests of the method which let us get the value of an environment
variable from a given environment file.
"""
self.temp_env_file.write("IS_THIS_A_GHOST=yes\n")
self.temp_env_file.seek(0)
self.helper.set_env_file_path(self.temp_env_file.name)
self.helper.set_name("IS_THIS_A_GHOST")
expected = "yes"
actual = self.helper.get_value_from_env_file()
self.assertEqual(expected, actual)
def test_get_value_from_file_not_found(self) -> None:
"""
Tests of the method which let us get the value of an environment
variable from a given environment file.
In this case, we test the case that the given value is not known.
"""
self.temp_env_file.write("IS_THIS_A_GHOST_NOOOO=yes")
self.temp_env_file.seek(0)
self.helper.set_env_file_path(self.temp_env_file.name)
self.helper.set_name("IS_THIS_A_GHOST")
expected = "hello"
actual = self.helper.get_value_from_env_file(default="hello")
self.assertEqual(expected, actual)
def test_set_value(self) -> None:
"""
Tests of the method which let us set the value of an environment
variable.
"""
expected = False
actual = self.helper.set_name(self.test_name).exists()
self.assertEqual(expected, actual)
self.helper.set_value("Hello, World!")
expected = "Hello, World!"
actual = self.helper.get_value()
self.assertEqual(expected, actual)
del os.environ[self.test_name]
def test_set_value_in_env_file(self) -> None:
"""
Tests of the method which let us set the value of an environment
variable into a file.
"""
self.helper.set_env_file_path(self.temp_env_file.name)
self.helper.set_name("GHOST_FINDER")
self.assertIsNone(self.helper.get_value())
expected = 'GHOST_FINDER="no"\n'
self.helper.set_value_in_env_file("no")
with open(self.temp_env_file.name, "r",
encoding="utf-8") as file_stream:
self.assertTrue("no" in file_stream.read())
expected = "no"
self.assertEqual(expected, self.helper.get_value())
def test_set_value_not_str(self) -> None:
"""
Tests of the method which let us set the value of an environment
variable for the case that the given value to set is not a string.
"""
expected = False
actual = self.helper.set_name(self.test_name).exists()
self.assertEqual(expected, actual)
self.assertRaises(TypeError,
lambda: self.helper.set_value(["Hello", "World!"]))
def test_delete(self) -> None:
"""
Tests of the method which let us delete an environment variable.
"""
expected = False
actual = self.helper.set_name(self.test_name).exists()
self.assertEqual(expected, actual)
self.helper.set_value("Hello, World!")
expected = True
actual = self.helper.exists()
self.assertEqual(expected, actual)
self.helper.delete()
expected = False
actual = self.helper.exists()
self.assertEqual(expected, actual)
def test_delete_value_in_env_file(self) -> None:
"""
Tests of the method which let us delete the value of an environment
variable into a file.
"""
self.temp_env_file.write("GHOST_SPEAKER=yes\n")
self.helper.set_env_file_path(self.temp_env_file.name)
self.helper.set_name("GHOST_SPEAKER")
self.helper.set_value("no")
with open(self.temp_env_file.name, "r",
encoding="utf-8") as file_stream:
self.assertTrue(self.helper.name in x
for x in file_stream.readlines())
self.helper.delete_from_env_file()
with open(self.temp_env_file.name, "r",
encoding="utf-8") as file_stream:
self.assertTrue(self.helper.name not in x
for x in file_stream.readlines())
self.assertIsNone(self.helper.get_value())
from pyfunceble_webworker import __version__
from pyfunceble_webworker.core.defaults import assets as assets_defaults
from pyfunceble_webworker.core.defaults import pyfunceble as pyfunceble_defaults
from pyfunceble_webworker.core.defaults import routes as routes_defaults
from pyfunceble_webworker.core.settings import core_settings
from pyfunceble_webworker.models.info import CoreLocation
from pyfunceble_webworker.models.links import Links
from pyfunceble_webworker.routes.v1.api import api_router as v1_api_router
env_var_helper = EnvironmentVariableHelper()
if not env_var_helper.set_name("PYFUNCEBLE_WORKERS_DATA_DIR").exists():
raise RuntimeError(
"Could not find PYFUNCEBLE_WORKERS_DATA_DIR environment variable.")
pyfunceble_webworker.storage.CONFIG_DIRECTORY = env_var_helper.get_value()
PyFunceble.storage.CONFIG_DIRECTORY = os.path.join(
pyfunceble_webworker.storage.CONFIG_DIRECTORY,
secrets.token_hex(8),
)
DirectoryHelper(PyFunceble.storage.CONFIG_DIRECTORY).create()
DirectoryHelper(pyfunceble_webworker.storage.CONFIG_DIRECTORY).create()
file_helper = FileHelper()
pyfunceble_config_loader = ConfigLoader()
if file_helper.set_path(
os.path.join(
pyfunceble_webworker.storage.CONFIG_DIRECTORY,
class Orchestration:
"""
This is the orchestration class. It orchestrate the test and production of
output with the help of PyFunceble.
:param administration:
A instance of the admintration management class.
"""
STD_PROTOCOL: dict = {
"type": None,
"subject_type": None,
"destination": None,
"source": None,
"abs_source": None,
"rel_source": None,
"subject": None,
"idna_subject": None,
"output_dir": None,
"checker_type": None,
"session_id": None,
}
administration: Optional[Administration] = None
tester_process_manager: Optional[TesterProcessesManager] = None
producer_process_manager: Optional[ProducerProcessesManager] = None
github_api: Optional[Github] = None
kill_switch: Optional[EnvironmentVariableHelper] = None
def __init__(
self,
administration: Administration,
) -> None:
self.administration = administration
self.system_launcher = UHBPyFuncebleSystemLauncher(
administration=self.administration)
env_helper = EnvironmentVariableHelper("GITHUB_TOKEN")
self.kill_switch = EnvironmentVariableHelper("UHB_GH_KILL_SWITCH")
self.github_api = Github(env_helper.get_value(default=None))
def submit_error_issue(self, *, trace: str) -> None:
"""
Submits an issue to the dev-center.
:param trace:
The traceback to embed inside the issue.
"""
issue_title = f"[ERROR] An error occurred in {self.administration.name}"
issue_body = infrastructure.AUTOMATED_ISSUE_TEMPLATE % {
"name": self.administration.name,
"error_detail": trace,
}
if not self.kill_switch.get_value():
repository = self.github_api.get_repo(
infrastructure.AUTOMATED_ISSUE_REPOSITORY)
repository.create_issue(
title=issue_title,
assignee=infrastructure.AUTOMATED_ISSUE_ASSIGNEE,
body=issue_body,
)
else:
print(issue_body)
sys.exit(1)
def start(self) -> "Orchestration":
"""
Starts the whole process of orchestration.
"""
try:
self.system_launcher.start()
except Exception:
self.submit_error_issue(trace=traceback.format_exc())
return self