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 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 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 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_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 __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 __init__(
self,
*,
token: Optional[str] = None,
url_base: Optional[str] = None,
preferred_status_origin: Optional[str] = None,
) -> None:
if token is not None:
self.token = token
else:
self.token = EnvironmentVariableHelper(
"PYFUNCEBLE_COLLECTION_API_TOKEN"
).get_value(default="")
if url_base is not None:
self.url_base = url_base
else:
self.guess_and_set_url_base()
if preferred_status_origin is not None:
self.preferred_status_origin = preferred_status_origin
else:
self.guess_and_set_preferred_status_origin()
self.session = requests.Session()
self.session.headers.update(
{
"Authorization": f"Bearer {self.token}" if self.token else None,
"Content-Type": "application/json",
}
)
def tool() -> None:
"""
Provide our CLI.
"""
colorama.init(autoreset=True)
parser = argparse.ArgumentParser(
description="The launcher of the Dead-Hosts infrastructure.",
epilog=f"Crafted with {colorama.Style.BRIGHT}{colorama.Fore.RED}♥"
f"{colorama.Fore.RESET}{colorama.Style.RESET_ALL} "
f"by {colorama.Style.BRIGHT}{colorama.Fore.CYAN}Nissar Chababy "
"(@funilrys)",
)
parser.add_argument(
"-d",
"--debug",
help="Activate the logging in verbose mode..",
action="store_true",
)
parser.add_argument(
"-s",
"--save",
help="Declare a test as "
"'to be continued'.",
action="store_true",
)
parser.add_argument(
"-e",
"--end",
help="Declare a test as completely finished and generate `clean.list`.",
action="store_true",
)
parser.add_argument(
"-v",
"--version",
help="Show the version of and exit.",
action="version",
version="%(prog)s " + __version__,
)
arguments = parser.parse_args()
if arguments.debug or EnvironmentVariableHelper(
"INFRASTRUCTURE_DEBUG").exists():
debug_level = logging.DEBUG
else:
debug_level = logging.INFO
logging.basicConfig(format="[%(asctime)s::%(levelname)s] %(message)s",
level=debug_level)
logging.info("Launcher version: %s", __version__)
Orchestration(end=arguments.end, save=arguments.save)
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
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 guess_and_set_authorized(self) -> "Jenkins":
"""
Tries to guess the authorization.
"""
needed_environment_vars = ["JENKINS_URL", "JENKINS_HOME"]
if PyFunceble.facility.ConfigLoader.is_already_loaded():
if bool(PyFunceble.storage.CONFIGURATION.cli_testing.ci.active):
self.authorized = all(
EnvironmentVariableHelper(x).exists()
for x in needed_environment_vars)
else:
super().guess_and_set_authorized()
elif all(
EnvironmentVariableHelper(x).exists()
for x in needed_environment_vars):
self.authorized = True
else:
super().guess_and_set_authorized()
return self
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 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 __init__(self, merge_upstream: Optional[bool] = None) -> None:
with package_resources.path(
"PyFunceble.data.infrastructure",
PyFunceble.storage.DISTRIBUTED_CONFIGURATION_FILENAME,
) as file_path:
self.path_to_default_config = str(file_path)
self.path_to_config = os.path.join(
PyFunceble.storage.CONFIG_DIRECTORY,
PyFunceble.storage.CONFIGURATION_FILENAME,
)
self.path_to_overwrite_config = os.path.join(
PyFunceble.storage.CONFIG_DIRECTORY,
PyFunceble.storage.CONFIGURATION_OVERWRITE_FILENAME,
)
if merge_upstream is not None:
self.merge_upstream = merge_upstream
elif EnvironmentVariableHelper("PYFUNCEBLE_AUTO_CONFIGURATION").exists():
self.merge_upstream = True
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
"""
import os
from typing import List, Optional
from PyFunceble.helpers.environment_variable import EnvironmentVariableHelper
env_var = EnvironmentVariableHelper()
DEFAULT_EMAIL: str = "*****@*****.**"
UNDER_CI_ENVS: List[str] = ["GITHUB_ACTIONS"]
UNDER_CI: bool = any(env_var.set_name(x).exists() for x in UNDER_CI_ENVS)
WORKSPACE_DIR: Optional[str] = env_var.set_name("GITHUB_WORKSPACE").get_value(
default=os.getcwd())
GITHUB_TOKEN: Optional[str] = env_var.set_name("GITHUB_TOKEN").get_value(
default=None)
GIT_EMAIL: Optional[str] = env_var.set_name("GIT_EMAIL").get_value(
default=None)
GIT_NAME: str = env_var.set_name("GIT_NAME").get_value(default="dead-hostsbot")
GIT_BRANCH: str = env_var.set_name("GIT_BRANCH").get_value(default="master")
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
from PyFunceble.helpers.environment_variable import EnvironmentVariableHelper
from PyFunceble.helpers.file import FileHelper
from PyFunceble.helpers.merge import Merge
from starlette.middleware.cors import CORSMiddleware
import pyfunceble_webworker.storage
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()
class Logger:
"""
Provides our logging logic.
.. warning::
There is several way to activate the logging.
1. Through the :code:`PYFUNCEBLE_DEBUG_ON_SCREEN` environment variable.
2. Through the :code:`DEBUG_PYFUNCEBLE_ON_SCREEN` environment variable.
3. Through the :code:`PYFUNCEBLE_DEBUG` environment variable.
4. Through the :code:`DEBUG_PYFUNCEBLE` environment variable.
5. Through the :py:meth:`PyFunceble.logger.Logger.set_activated` method.
"""
# pylint: disable=too-many-public-methods
# pylint: disable=line-too-long
OWN_FORMAT: str = (
"[%(asctime)s | %(levelname)s | %(origin_path)s:"
"%(origin_line)s@%(origin_func)s | PPID%(process)d:%(processName)s]:\n"
"%(message)s\n"
)
"""
Our very own format.
"""
ROOT_FORMAT: str = (
"[%(asctime)s::%(levelname)s](PID%(process)s:%(processName)s): %(message)s"
)
"""
The format of the root loggy.
"""
STD_MIN_LEVEL: int = logging.INFO
_activated: bool = False
_min_level: int = logging.INFO
_output_directory: Optional[str] = None
own_formatter: logging.Formatter = logging.Formatter(OWN_FORMAT)
root_formatter: logging.Formatter = logging.Formatter(ROOT_FORMAT)
info_logger: Optional[logging.Logger] = None
debug_logger: Optional[logging.Logger] = None
warning_logger: Optional[logging.Logger] = None
error_logger: Optional[logging.Logger] = None
fatal_logger: Optional[logging.Logger] = None
critical_logger: Optional[logging.Logger] = None
sqlalchemy_logger: Optional[logging.Logger] = None
env_var_helper: EnvironmentVariableHelper = EnvironmentVariableHelper()
def __init__(
self,
*,
activated: Optional[bool] = None,
min_level: Optional[int] = None,
output_dir: Optional[str] = None,
) -> None:
if output_dir:
self.output_directory = output_dir
else:
self.output_directory = os.path.join(
PyFunceble.cli.storage.OUTPUT_DIRECTORY,
PyFunceble.cli.storage.OUTPUTS.logs.directories.parent,
)
if activated is not None:
self.activated = activated
if min_level is not None:
self.min_level = min_level
else:
self.guess_and_set_min_level()
@property
def on_screen(self) -> bool:
"""
Provides the authorization to log on screen.
"""
return (
self.env_var_helper.set_name("PYFUNCEBLE_DEBUG_ON_SCREEN").exists()
or self.env_var_helper.set_name("DEBUG_PYFUNCEBLE_ON_SCREEN").exists()
)
@property
def on_file(self) -> bool:
"""
Provides the authorization to log on file.
"""
return (
self.env_var_helper.set_name("PYFUNCEBLE_DEBUG").exists()
or self.env_var_helper.set_name("DEBUG_PYFUNCEBLE").exists()
)
@property
def activated(self) -> bool:
"""
Provides the current state of the :code:`_activated` attribute.
"""
return self._activated
@activated.setter
def activated(self, value: bool) -> None:
"""
Sets the value of the activated attribute.
:param value:
The value to set.
:raise TypeError:
When the given value is not a :py:class:`bool`.
"""
if not isinstance(value, bool):
raise TypeError(f"<value> should be {bool}, {type(value)} given.")
self._activated = value
def set_activated(self, value: bool) -> "Logger":
"""
Sets the value of the activated attribute.
:param value:
The value to set.
"""
self.activated = value
return self
@property
def min_level(self) -> int:
"""
Provides the current state of the :code:`_min_level` attribute.
"""
return self._min_level
@min_level.setter
def min_level(self, value: Union[int, str]) -> None:
"""
Sets the minimum level to log.
:param value:
The value to set.
:raise TypeError:
When the given value is not a :py:class:`int` or :py:class:`str`.
:raise ValueError:
When the given value is not supported
"""
if not isinstance(value, (int, str)):
raise TypeError(f"<value> should be {int} or {str}, {type(value)} given.")
# pylint: disable=protected-access
if isinstance(value, int) and value not in logging._levelToName:
raise ValueError(f"<value> is not in {list(logging._nameToLevel.keys())}")
if isinstance(value, str):
if value.upper() not in logging._nameToLevel:
raise ValueError(
f"<value> is not in {list(logging._nameToLevel.keys())}"
)
value = logging._nameToLevel[value.upper()]
self._min_level = value
return self
def set_min_level(self, value: Union[int, str]) -> "Logger":
"""
Sets the minimum level to log.
:param value:
The value to set.
"""
self.min_level = value
return self
@property
def output_directory(self) -> Optional[str]:
"""
Provides the current state of the :code:`_output_directory` attribute.
"""
if self.authorized:
DirectoryHelper(self._output_directory).create()
return self._output_directory
@output_directory.setter
def output_directory(self, value: str) -> None:
"""
Sets the directory to write.
Side Effect:
Creation of the given value if it does not exists.
:param value:
The value to set.
:raise TypeError:
When the given value is not a :py:class:`str`.
"""
if not isinstance(value, str):
raise TypeError(f"<value> should be {int}, {type(value)} given.")
self._output_directory = value
def set_output_directory(self, value: str) -> "Logger":
"""
Sets the directory to write.
:param value:
The value to set.
"""
self.output_directory = value
return self
@property
def authorized(self) -> bool:
"""
Provides the authorization to actually log.
"""
return (
self.activated
or self.on_screen
or self.on_file
or (
bool(PyFunceble.storage.CONFIGURATION)
and bool(PyFunceble.storage.CONFIGURATION.debug.active)
)
)
@staticmethod
def get_origin() -> dict:
"""
Provides the informatioon about where the logger was triggered.
:return:
A tuple, which is composed of the following.
(trigger file path, trigger line, trigger function/method name)
"""
stackback = [
y for x in [x.split("\n") for x in traceback.format_stack()] for y in x if y
]
interest = stackback[-6].split(",")
complete_file = interest[0].strip()[6:-1].split(os.sep)
try:
if complete_file[-2] != PyFunceble.storage.PROJECT_NAME:
file = "/".join(complete_file)
else:
file = "/".join(complete_file[-2:])
except IndexError:
file = "/".join(complete_file)
line = interest[1].strip().split()[-1].strip()
func_name = interest[2].strip()[3:]
if PyFunceble.storage.PROJECT_NAME in file:
file = os.path.relpath(file)
return {"origin_path": file, "origin_line": line, "origin_func": func_name}
def single_logger_factory(level_name: str): # pylint: disable=no-self-argument
"""
Provides the general factory.
:param level_name:
The level to log.
"""
def single_logger(func):
@functools.wraps(func)
def wrapper(self, *args, **kwargs):
# pylint: disable=no-member, protected-access
if (
self.authorized
and logging._nameToLevel[level_name.upper()] >= self.min_level
):
try:
logger = getattr(
getattr(self, f"{level_name.lower()}_logger"),
level_name.lower(),
)
if not logger:
self.init_loggers()
except AttributeError:
self.init_loggers()
logger = getattr(
getattr(self, f"{level_name.lower()}_logger"),
level_name.lower(),
)
return logger(*args, **kwargs, extra=self.get_origin())
return func
return wrapper
return single_logger
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 guess_all_settings(self) -> "Logger":
"""
Try to guess all settings.
"""
to_ignore = ["guess_all_settings"]
for method in dir(self):
if method in to_ignore or not method.startswith("guess_"):
continue
getattr(self, method)()
return self
def destroy_loggers(self) -> "Logger":
"""
Destroyes all existing loggers.
"""
for logger, level in self.get_next_logger():
logger.handlers.clear()
delattr(self, f"{level}_logger")
setattr(self, f"{level}_logger", None)
def get_next_logger(self) -> Generator[None, Tuple[logging.Logger, str], None]:
"""
Provides the next logger.
"""
for logger_var_name in Logger.__dict__:
if (
not logger_var_name.endswith("_logger")
or logger_var_name == "get_next_logger"
or "sqlalchemy" in logger_var_name
):
continue
level = logger_var_name.split("_", 1)[0]
if not getattr(self, logger_var_name):
setattr(self, logger_var_name, logging.getLogger(f"PyFunceble.{level}"))
yield getattr(self, logger_var_name), level
def init_loggers(self) -> "Logger":
"""
Init all our logger.
"""
if self.authorized:
self.destroy_loggers()
if not self.sqlalchemy_logger:
self.sqlalchemy_logger = logging.getLogger("sqlalchemy")
self.sqlalchemy_logger.setLevel(self.min_level)
self.sqlalchemy_logger.propagate = False
for logger, level in self.get_next_logger():
logger.propagate = False
# pylint: disable=protected-access
logger.setLevel(logging._nameToLevel[level.upper()])
logger.addHandler(self.get_handler(level))
return self
def get_handler(
self, level_name: str
) -> Optional[Union[logging.StreamHandler, logging.handlers.RotatingFileHandler]]:
"""
Given a level name, this method provides the right handler for it!
"""
level_name = level_name.upper()
specials = ["SQLALCHEMY"]
if hasattr(logging, level_name) or level_name in specials:
if self.on_screen:
handler = logging.StreamHandler()
else:
handler = logging.handlers.RotatingFileHandler(
os.path.join(self.output_directory, f"{level_name.lower()}.log"),
maxBytes=100_000_000,
backupCount=5,
)
if level_name in specials:
handler.setLevel(self.min_level)
handler.setFormatter(self.root_formatter)
else:
handler.setLevel(getattr(logging, level_name))
handler.setFormatter(self.own_formatter)
return handler
return None
@single_logger_factory("info")
def info(self, *args, **kwargs):
"""
Logs to the PyFunceble.info logger.
"""
@single_logger_factory("debug")
def debug(self, *args, **kwargs):
"""
Logs to the PyFunceble.debug logger.
"""
@single_logger_factory("warning")
def warning(self, *args, **kwargs):
"""
Logs to the PyFunceble.warning logger.
"""
@single_logger_factory("error")
def error(self, *args, **kwargs):
"""
Logs to the PyFunceble.error logger.
"""
@single_logger_factory("fatal")
def fatal(self, *args, **kwargs):
"""
Logs to the PyFunceble.fatal logger.
"""
@single_logger_factory("critical")
def critical(self, *args, **kwargs):
"""
Logs to the PyFunceble.critical logger.
"""
@single_logger_factory("exception")
def exception(self, *args, **kwargs):
"""
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
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
"""
import os
from github import Github
from PyFunceble.helpers.command import CommandHelper
from PyFunceble.helpers.directory import DirectoryHelper
from PyFunceble.helpers.environment_variable import EnvironmentVariableHelper
from PyFunceble.helpers.file import FileHelper
USER_TOKEN = EnvironmentVariableHelper("GITHUB_TOKEN").get_value()
USER_GIT_EMAIL = EnvironmentVariableHelper("GIT_EMAIL").get_value()
USER_GIT_NAME = EnvironmentVariableHelper("GIT_NAME").get_value()
ORG_NAME = "dead-hosts"
CLONE_TEMPLATE = f"https://{USER_TOKEN}@github.com/%slug%.git"
DEPLOYMENT_DIR = "to_deploy"
CLONE_DIR = "clones"
DEPLOY_FILES_TO_IGNORE = []
COMMIT_MESSAGE = "Sync actions."
REPOS_TO_IGNORE = [
".github",
"template",
"actions-sync",
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()
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())
