255 lines
9.7 KiB
Python
255 lines
9.7 KiB
Python
from datetime import date
|
|
import json
|
|
|
|
class Service:
|
|
"""
|
|
Application déployée sur un serveur.
|
|
"""
|
|
def __init__(self, name: str, port: str | int, protocol: str, is_critical: bool):
|
|
self.name = name
|
|
self.port = int(port)
|
|
self.protocol = protocol
|
|
self.is_critical = is_critical
|
|
|
|
def __eq__(self, other: "Service"):
|
|
return self.name == other.name and self.port == other.port
|
|
|
|
def serialized_services(self):
|
|
"""Converti la classe \"Services\" en dictionnaire JSONable"""
|
|
return {
|
|
"Name": self.name,
|
|
"Port": self.port,
|
|
"Protocol": self.protocol,
|
|
"Is_Critical": self.is_critical,
|
|
}
|
|
|
|
@classmethod
|
|
def deserialized_services(cls, dictionnary):
|
|
"""Lis un JSON pour le retranscrire en classe \"Services\""""
|
|
return cls(
|
|
name= dictionnary["Name"],
|
|
port= dictionnary["Port"],
|
|
protocol= dictionnary["Protocol"],
|
|
is_critical= dictionnary["Is_Critical"],
|
|
)
|
|
|
|
class Serveur:
|
|
"""
|
|
Serveur, classe maîtresse. NE PAS UTILISER DIRECTEMENT.
|
|
Préférez les classes héritées :
|
|
- ServeurPhysique
|
|
- ServeurVirtuel
|
|
"""
|
|
def __init__(self, name: str, ip_address: str, os_name: str, commission_date: date):
|
|
self.name = name
|
|
self.ip_address = ip_address
|
|
self.os_name = os_name
|
|
self.commission_date = commission_date
|
|
self.services = self.load_services()
|
|
|
|
def __str__(self) -> str:
|
|
return f"\
|
|
[Serveur] > {self.name}\n\
|
|
[Addresse IP] > {self.ip_address}\n\
|
|
[Système d'Exploitation] > {self.os_name}\n\
|
|
[Date de mise en prod] > {self.commission_date}"
|
|
|
|
def __len__(self) -> int:
|
|
return len(self.services)
|
|
|
|
def list_services(self):
|
|
return self.services
|
|
|
|
def add_service(self, service: Service):
|
|
"""Ajout d'un service à la liste des services disponibles"""
|
|
if service in self.services:
|
|
return f"Le service [{service.name.capitalize()}] est déjà présent."
|
|
self.services.append(service)
|
|
self.save_services()
|
|
return f"{service.name.capitalize()} a été ajouté."
|
|
|
|
def remove_service(self, service_str: str):
|
|
"""Retire un service de la liste des services disponibles"""
|
|
for service in self.services:
|
|
if service.name.lower() == service_str.lower()\
|
|
or str(service.port) == service_str.lower()\
|
|
or service.protocol.lower() == service_str.lower():
|
|
self.services.remove(service)
|
|
self.save_services()
|
|
return f"{service.name.capitalize} a été retiré."
|
|
return f"{service.name.capitalize()} n'est pas dans la liste."
|
|
|
|
def serialized_servers(self):
|
|
"""Converti la classe \"Services\" en dictionnaire JSONable"""
|
|
return {
|
|
"Name": self.name,
|
|
"IP_Address": self.ip_address,
|
|
"OS_Name": self.os_name,
|
|
"Commission_Date": self.commission_date,
|
|
}
|
|
|
|
@classmethod
|
|
def deserialized_servers(cls, dictionnary):
|
|
"""Lis un JSON pour le retranscrire en classe \"Services\""""
|
|
return cls(
|
|
name= dictionnary["Name"],
|
|
ip_address= dictionnary["IP_Address"],
|
|
os_name= dictionnary["OS_Name"],
|
|
commission_date= dictionnary["Commission_Date"],
|
|
)
|
|
|
|
def save_services(self):
|
|
"""
|
|
Inscris dans un fichier JSON le contenu des services disponibles
|
|
"""
|
|
services_dict = [services.serialized_services() for services in self.services]
|
|
with open("services.json", "w", encoding= "utf-8") as json_file:
|
|
json.dump(services_dict, json_file, indent= 4)
|
|
|
|
def load_services(self) -> list[Service]:
|
|
"""
|
|
Récupère le contenu d'un fichier JSON contenant les services
|
|
"""
|
|
with open("services.json", encoding= "utf-8") as json_file:
|
|
return json.load(json_file, object_hook= Service.deserialized_services)
|
|
|
|
class ServeurPhysique(Serveur):
|
|
def __init__(self, name: str, ip_address: str, os_name: str, commission_date: date, rack: str, electric_cons: int, warranty: bool):
|
|
super().__init__(name, ip_address, os_name, commission_date)
|
|
self.rack = rack
|
|
self.electric_cons = electric_cons
|
|
warranty_bools = ("Non", "Oui")
|
|
self.warranty = warranty_bools[warranty]
|
|
|
|
def __str__(self) -> str:
|
|
return f"\
|
|
{super().__str__()}\n\
|
|
[Châssis] > {self.rack}\n\
|
|
[Consommation en kWh] > {self.electric_cons}\n\
|
|
[Sous garantie] > {self.warranty}"
|
|
|
|
def __len__(self) -> int:
|
|
return super().__len__()
|
|
|
|
class ServeurVirtuel(Serveur):
|
|
def __init__(self, name: str, ip_address: str, os_name: str, commission_date: date, hypervisor: str, vcpus: int, giga_ram: float):
|
|
super().__init__(name, ip_address, os_name, commission_date)
|
|
self.hypervisor = hypervisor
|
|
self.vcpus = vcpus
|
|
self.giga_ram = giga_ram
|
|
|
|
def __str__(self) -> str:
|
|
return f"\
|
|
{super().__str__()}\n\
|
|
[Hyperviseur] > {self.hypervisor}\n\
|
|
[Coeurs virtuels] > {self.vcpus}\n\
|
|
[Mémoire vive (Go)] > {self.giga_ram}"
|
|
|
|
def __len__(self) -> int:
|
|
return super().__len__()
|
|
|
|
class Maintenance:
|
|
def __init__(self, id: int, commission_date: date, type: str, affected_technician: "Technicien", associated_server: "ServeurPhysique | ServeurVirtuel"):
|
|
self.id = id
|
|
self.commission_date = commission_date
|
|
self.type = type
|
|
self.affected_technician = affected_technician
|
|
self.associated_server = associated_server
|
|
|
|
def __str__(self) -> str:
|
|
return f"\
|
|
[ID] > {self.id}\n\
|
|
[Serveur associé] > {self.associated_server}\n\
|
|
[Date de mise en prod] > {self.commission_date}\n\
|
|
[Type de maintenance] > {self.type}\n\
|
|
[Technicien affecté] > {self.affected_technician}"
|
|
|
|
# J'ai le sentiment que ce n'est PAS ce qui est demandé. Mais il est 16h25 et je n'ai plus d'idée sur comment le faire
|
|
def link_to_server(self, server: ServeurPhysique | ServeurVirtuel):
|
|
return f"La maintenance est liée au serveur {server.name.upper()}, addresse IP {server.ip_address}."
|
|
|
|
def serialized_maintenances(self):
|
|
"""Converti la classe \"Maintenance\" en dictionnaire JSONable"""
|
|
return {
|
|
"ID": self.id,
|
|
"Associated_Server": self.associated_server,
|
|
"Commission_Date": self.commission_date,
|
|
"Type": self.type,
|
|
"Affected_Technician": self.affected_technician,
|
|
}
|
|
|
|
@classmethod
|
|
def deserialized_maintenances(cls, dictionnary):
|
|
"""Lis un JSON pour le retranscrire en classe \"Maintenance\""""
|
|
return cls(
|
|
id= dictionnary["ID"],
|
|
associated_server= dictionnary["Associated_Server"],
|
|
commission_date= dictionnary["Commission_Date"],
|
|
type= dictionnary["Type"],
|
|
affected_technician= dictionnary["Affected_Technician"],
|
|
)
|
|
|
|
class Technicien:
|
|
def __init__(self, fullname: str, speciality: str, id: int):
|
|
self.name = fullname
|
|
self.speciality = speciality
|
|
self.id = id
|
|
self.maintenances = self.load_maintenances()
|
|
|
|
def list_affected_jobs(self):
|
|
return self.maintenances
|
|
|
|
def affect_maintenance(self):
|
|
pass
|
|
|
|
def save_maintenances(self):
|
|
"""
|
|
Inscris dans un fichier JSON le contenu des maintenances disponibles
|
|
"""
|
|
maintenances_dict = [maintenances.serialized_maintenances() for maintenances in self.maintenances]
|
|
with open("maintenances.json", "w", encoding= "utf-8") as json_file:
|
|
json.dump(maintenances_dict, json_file, indent= 4)
|
|
|
|
def load_maintenances(self) -> list[Maintenance]:
|
|
"""
|
|
Récupère le contenu d'un fichier JSON contenant les maintenances
|
|
"""
|
|
with open("maintenances.json", encoding= "utf-8") as json_file:
|
|
return json.load(json_file, object_hook= Maintenance.deserialized_maintenances)
|
|
|
|
class Datacenter:
|
|
def __init__(self, name: str, location: str, id: int):
|
|
self.name = name
|
|
self.location = location
|
|
self.id = id
|
|
self.servers = self.load_servers()
|
|
|
|
def list_servers(self):
|
|
return self.servers
|
|
|
|
def list_critical_services(self):
|
|
for server in self.servers:
|
|
server.list_services()
|
|
# Là j'ai cherché à récupérer un genre de 'if server.list_services().is_critical'
|
|
# pour avoir le "True/False" et renvoyer le résultat en cas de "True" mais j'ai craqué
|
|
|
|
def list_services_number(self):
|
|
services = 0
|
|
for server in self.servers:
|
|
services += len(server)
|
|
return services
|
|
|
|
def save_servers(self):
|
|
"""
|
|
Inscris dans un fichier JSON le contenu des serveurs disponibles
|
|
"""
|
|
servers_dict = [servers.serialized_servers() for servers in self.servers]
|
|
with open("servers.json", "w", encoding= "utf-8") as json_file:
|
|
json.dump(servers_dict, json_file, indent= 4)
|
|
|
|
def load_servers(self) -> list[Serveur]:
|
|
"""
|
|
Récupère le contenu d'un fichier JSON contenant les serveurs
|
|
"""
|
|
with open("servers.json", encoding= "utf-8") as json_file:
|
|
return json.load(json_file, object_hook= Serveur.deserialized_servers) |