393 lines
15 KiB
Python
393 lines
15 KiB
Python
import requests
|
|
import urllib3
|
|
import sys
|
|
import time
|
|
import threading
|
|
import logging
|
|
import os
|
|
import errno
|
|
|
|
from concurrent.futures import ThreadPoolExecutor
|
|
from dotenv import load_dotenv
|
|
from vmware.vapi.vsphere.client import create_vsphere_client
|
|
from com.vmware.vcenter_client import VM
|
|
from com.vmware.vcenter.vm_client import Power as PowerHardware
|
|
from com.vmware.vcenter.vm.guest_client import Power as PowerGuest
|
|
|
|
# Variables
|
|
wait_power_on = 60 # Tiempo de espera entre grupos de máquinas
|
|
wait_power_off = 60 # Tiempo de espera entre grupos de máquinas
|
|
wait_tools_on = 120 # Tiempo de espera para que las tools esten activas
|
|
wait_tools_off = 120 # Tiempo de espera para que las tools esten apagadas
|
|
timeout_on = 1200 # Tiempo de espera para que se de la máquina por encendida
|
|
timeout_off = 1200 # Tiempo de espera hasta forzar el apagado de la maquina
|
|
operation = "none" # Modo de operación: encendido o apagado
|
|
# Grupo de máquinas sobre las que se aplicará el modo de energía (NOMBRE)
|
|
group_selected = "none"
|
|
vms = "none" # Máquinas que se van a utilizar en la ejecución del script
|
|
|
|
# TEST
|
|
vms_test_g1 = ["test1", "test2"]
|
|
vms_test_g2 = ["test3", "test4", "test5"]
|
|
vms_test_g3 = ["test6", "test7", "test8", "test9", "test10"]
|
|
|
|
# TEST2
|
|
vms_test_g4 = ["test1", "test2", "test3", "test4",
|
|
"test5", "test6", "test7", "test8", "test9", "test10"]
|
|
|
|
# PRODUCCIÓN
|
|
vm_sin_grupo = ["alarmas_ayto", "alarmas_cpd", "cita_previa", "daloradius_biblioteca", "deep_freeze2", "editrans2", "edu_latorre", "gestion_switches", "impresoras_ricoh", "inattend2", "lucia", "micollab-mbg", "micollab9.4", "museo_domus", "ofimatico2007", "ofimatico2019",
|
|
"pulse_secure", "tarificador", "tc_aplicaciones", "tc_balanceador", "tc_bbdd", "tc_wserver", "untangle_biblioteca", "web_pre", "webdmz", "wifimovi", "tao_consultores1", "tao_consultores2", "tao_consultores3", "temporizador_pleno", "wazuh4.3.6"]
|
|
vm_apagadas = ["adnperros", "autocad2010", "control_biblio", "gisabsis", "glpi", "gwdmz15", "helpdesk",
|
|
"inventario_igs", "oes2018_pruebas", "open_erp", "pacmer", "presencia", "severino", "verticales_telefonica_camaras"]
|
|
vm_grupo_0 = ["datacore-cpd", "datacore-pol", "vcsa7"]
|
|
vm_grupo_1 = ["sacrista", "paco", "synology", "hp1440"]
|
|
vm_grupo_2 = ["torero", "oraserver19", "oraserver19_pre",
|
|
"ndsmaster", "storeonce1", "storeonce2"]
|
|
vm_grupo_3 = ["ayto_web_int", "documentum2016", "geoserver_lan", "peseta2",
|
|
"taoactuate", "abaco", "intranet2016", "intranet2_pre", "petrolio2"]
|
|
vm_grupo_4 = ["ayto_web_ext2", "geoserver_pre",
|
|
"tao1", "tao1_pre", "tirisiti2"]
|
|
vm_grupo_5 = ["clasico", "gw01-19", "gw02-19", "geoserver_pro", "otrs", "taoapps1_wildfly", "taoapps2_wildfly", "taoapps3_wildfly", "taoapps_pre_wildfly",
|
|
"tereseta2", "fortianalyzer", "fortimail", "veeam", "taobalanceador_wildfly", "taosede_9", "taosede_9_pre", "filr4"]
|
|
vm_grupo_6 = ["datasync_gms15", "gwdmz"]
|
|
vm_grupo_7 = ["centreon2", "zabbix"]
|
|
|
|
# ORACLE
|
|
vm_oracle_0 = ["oraserver19", "oraserver19_pre"]
|
|
vm_oracle_1 = ["ayto_web_int", "documentum2016", "geoserver_lan", "peseta2",
|
|
"taoactuate", "abaco", "intranet2016", "intranet2_pre"]
|
|
vm_oracle_2 = ["ayto_web_ext2", "geoserver_pre", "tao1", "tao1_pre"]
|
|
vm_oracle_3 = ["geoserver_pro", "taoapps1_wildfly", "taoapps2_wildfly", "taoapps3_wildfly",
|
|
"taoapps_pre_wildfly", "taobalanceador_wildfly", "taosede_9", "taosede_9_pre"]
|
|
|
|
# GEOSERVERS
|
|
g1 = ["geoserver_lan"]
|
|
g2 = ["geoserver_pre"]
|
|
g3 = ["geoserver_pro"]
|
|
|
|
# Orden de encendido de las máquinas de test
|
|
vms_test1 = [vms_test_g1, vms_test_g2, vms_test_g3]
|
|
vms_test2 = [vms_test_g4]
|
|
vms_oracle = [vm_oracle_0, vm_oracle_1, vm_oracle_2, vm_oracle_3]
|
|
vms_produccion = [vm_grupo_2, vm_grupo_3, vm_grupo_4,
|
|
vm_grupo_5, vm_grupo_6, vm_sin_grupo, vm_grupo_7]
|
|
vms_geo = [g1, g2, g3]
|
|
|
|
# Listados con los diferentes grupos de máquinas
|
|
groups = [vms_test1, vms_test2, vms_oracle, vms_produccion, vms_geo]
|
|
group_names = ["TEST1", "TEST2", "ORACLE", "PRODUCCION", "GEOSERVERS"]
|
|
|
|
def get_vm(client, vm_name):
|
|
# Return the identifier of a vm
|
|
# Note: The method assumes that there is only one vm with the mentioned name.
|
|
names = set([vm_name])
|
|
vms = client.vcenter.VM.list(VM.FilterSpec(names=names))
|
|
|
|
if len(vms) == 0:
|
|
return None
|
|
|
|
vm = vms[0].vm
|
|
return vm
|
|
|
|
|
|
def power_off_vm(client, vm, name):
|
|
# Si la maquina existe
|
|
if vm != None:
|
|
# Obtiene el estado (encendida o apagada)
|
|
status = client.vcenter.vm.Power.get(vm)
|
|
timeout_shutdown = time.time() + timeout_off
|
|
|
|
# Repite hasta que se apague o se acabe el tiempo
|
|
while status.state == PowerHardware.State.POWERED_ON:
|
|
status = client.vcenter.vm.Power.get(vm)
|
|
guest_status = client.vcenter.vm.guest.Power.get(vm).state
|
|
# El sistema operativo está funcionando
|
|
if guest_status == PowerGuest.State.RUNNING:
|
|
tools = client.vcenter.vm.guest.Power.get(vm).operations_ready
|
|
# Las tools estan operativas
|
|
if tools == True:
|
|
logging.info("%s: Enviada señal de apagado", name)
|
|
client.vcenter.vm.guest.Power.shutdown(vm)
|
|
# Espera hasta que las tools ya no esten disponibles o salte el time out
|
|
timeout_tools = time.time() + wait_tools_off
|
|
while tools == True:
|
|
tools = client.vcenter.vm.guest.Power.get(
|
|
vm).operations_ready
|
|
time.sleep(1)
|
|
if time.time() > timeout_tools:
|
|
logging.info("%s: Timeout tools", name)
|
|
break
|
|
logging.info("%s: Apagandose ...", name)
|
|
time.sleep(5)
|
|
if time.time() > timeout_shutdown:
|
|
logging.info("%s: Forzando apagado ...", name)
|
|
client.vcenter.vm.power.stop(vm)
|
|
break
|
|
logging.info("%s: Apagada", name)
|
|
return True
|
|
|
|
# Si la máquina no existe
|
|
else:
|
|
logging.info("%s: No existe", name)
|
|
return False
|
|
|
|
|
|
def power_on_vm(client, vm, name):
|
|
# Si la maquina existe
|
|
if vm != None:
|
|
# Obtiene el estado (encendida o apagada)
|
|
status = client.vcenter.vm.Power.get(vm)
|
|
|
|
# Repite hasta que se encienda
|
|
while status.state == PowerHardware.State.POWERED_OFF:
|
|
client.vcenter.vm.Power.start(vm)
|
|
logging.info("%s: Enviada señal de encendido", name)
|
|
|
|
# Espera hasta que las tools esten disponibles o salte el time out
|
|
timeout_tools = time.time() + wait_tools_on
|
|
tools = client.vcenter.vm.guest.Power.get(vm).operations_ready
|
|
while tools == False:
|
|
time.sleep(5)
|
|
tools = client.vcenter.vm.guest.Power.get(vm).operations_ready
|
|
logging.info("%s: Encendiendose", name)
|
|
if time.time() > timeout_tools:
|
|
logging.info("%s: Timeout tools", name)
|
|
break
|
|
|
|
# Comprueba el estado
|
|
status = client.vcenter.vm.Power.get(vm)
|
|
|
|
# La máquina ya está encendida
|
|
logging.info("%s: Encendida", name)
|
|
return True
|
|
|
|
# Si la máquina no existe
|
|
else:
|
|
logging.warning("%s: no existe", name)
|
|
return False
|
|
|
|
|
|
def printHelp(prog):
|
|
print("\nFUNCIONAMIENTO")
|
|
print("\tpython3 " + prog + " OPCIONES\n")
|
|
|
|
print("OPCIONES")
|
|
print("\t -h, --help:")
|
|
print("\t\tMuestra esta ayuda\n")
|
|
|
|
print("\t -l, --list:")
|
|
print("\t\tLista los posibles grupos de maquinas virtuales para operar\n")
|
|
|
|
print("\t -l, --list NOMBRE_GRUPO:")
|
|
print("\t\tLista los nombres de las máquinas virtuales que pertenecen al grupo NOMBRE_GRUPO\n")
|
|
|
|
print("\t -g, --group NOMBRE_GRUPO:")
|
|
print("\t\tEstablece el grupo de maquinas virtuales sobre el cual se aplicará el modo de energía\n")
|
|
|
|
print("\t -p, --power on|off:")
|
|
print("\t\tIndica el modo de operación de energía que se aplicará a las máquians virtuales")
|
|
print("\t\t--power on: Enciende las máquinas virtuales del grupo seleccionado")
|
|
print("\t\t--power off: Apaga las máquinas virtuales del grupo seleccionado\n")
|
|
|
|
print("EJEMPLO")
|
|
print("\tpython3 " + prog + " --power on --group ORACLE\n")
|
|
|
|
|
|
def checkArgs(args):
|
|
global operation
|
|
operation = "none"
|
|
global group_selected
|
|
group_selected = "none"
|
|
global vms
|
|
vms = "none"
|
|
|
|
for index in range(0, len(args)):
|
|
# POWER
|
|
if args[index] == "--power" or args[index] == "-p":
|
|
if index < len(args)-1:
|
|
if args[index+1] == "on":
|
|
operation = "on"
|
|
elif args[index+1] == "off":
|
|
operation = "off"
|
|
|
|
# LIST
|
|
if args[index] == "--list" or args[index] == "-l":
|
|
operation = "none"
|
|
# Comprueba que el argumento list es el último o no contiene un nombre de grupo válido detras
|
|
if index == len(args)-1 or (index <= len(args)-1 and args[index+1] not in group_names):
|
|
print("Los grupos de máquinas disponibles son los siguientes:")
|
|
for group in group_names:
|
|
print("- "+group)
|
|
|
|
# Comprueba que el argumento posterior pertenece a un grupo
|
|
if index < len(args)-1:
|
|
if args[index+1] in group_names:
|
|
num = group_names.index(args[index+1])
|
|
num_group = 1
|
|
for group in groups[num]:
|
|
print("Grupo", num_group)
|
|
num_group += 1
|
|
for mv in group:
|
|
print("\t" + mv)
|
|
|
|
# GROUP
|
|
if args[index] == "--group" or args[index] == "-g":
|
|
group_selected = "none"
|
|
# Comprueba que el argumento posterior pertenece a un grupo
|
|
if index < len(args)-1:
|
|
if args[index+1] in group_names:
|
|
group_selected = args[index+1]
|
|
num = group_names.index(group_selected)
|
|
vms = groups[num]
|
|
|
|
# HELP
|
|
if args[index] == "--help" or args[index] == "-h":
|
|
operation = "none"
|
|
printHelp(args[0])
|
|
|
|
if len(args) == 1:
|
|
operation = "none"
|
|
printHelp(args[0])
|
|
|
|
|
|
def main():
|
|
# Comprueba los argumentos
|
|
checkArgs(sys.argv)
|
|
print("operation", operation)
|
|
vms = vms_test1
|
|
print("vms", vms)
|
|
|
|
# ~Si no tiene los parametros necesarios, sale del programa
|
|
if (operation == "none" or vms == "none"):
|
|
sys.exit()
|
|
|
|
# Crea el directorio para los logs
|
|
try:
|
|
os.mkdir('log')
|
|
except OSError as e:
|
|
if e.errno != errno.EEXIST:
|
|
raise
|
|
|
|
# Obtiene la fecha y hora de inicio
|
|
ini_timestr = time.strftime("%Y%m%d-%H%M%S")
|
|
|
|
# Inicia el log
|
|
logging.basicConfig(level=logging.INFO,
|
|
format='%(asctime)s %(name)-12s %(levelname)-8s %(message)s',
|
|
encoding='utf-8',
|
|
datefmt='%m-%d %H:%M',
|
|
filename='log/' + ini_timestr + '.log',
|
|
filemode='w')
|
|
|
|
# Define a Handler which writes INFO messages or higher to the sys.stderr
|
|
console = logging.StreamHandler()
|
|
console.setLevel(logging.INFO)
|
|
|
|
# Set a format which is simpler for console use
|
|
formatter = logging.Formatter('%(levelname)-8s>> %(message)s')
|
|
|
|
# Tell the handler to use this format
|
|
console.setFormatter(formatter)
|
|
|
|
# Add the handler to the root logger
|
|
logging.getLogger().addHandler(console)
|
|
# logging.info("Empieza el programa\n")
|
|
|
|
session = requests.session()
|
|
|
|
# Disable cert verification for demo purpose.
|
|
# This is not recommended in a production environment.
|
|
session.verify = False
|
|
|
|
# Disable the secure connection warning for demo purpose.
|
|
# This is not recommended in a production environment.
|
|
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
|
|
|
|
# Obtiene la información desde el fichero .env
|
|
load_dotenv()
|
|
vcenter_server = os.getenv('VCENTER_SERVER')
|
|
vcenter_username = os.getenv('VCENTER_USERNAME')
|
|
vcenter_password = os.getenv('VCENTER_PASSWORD')
|
|
|
|
print("vcenter_server", vcenter_server)
|
|
|
|
# Connect to a vCenter Server using username and password
|
|
client = create_vsphere_client(
|
|
server=vcenter_server, username=vcenter_username, password=vcenter_password, session=session)
|
|
|
|
# Bucle principal
|
|
main_loop(client, operation)
|
|
# logging.info("Acaba el programa")
|
|
|
|
|
|
def main_loop(client, operation):
|
|
|
|
# Enciende máquinas
|
|
if operation == "on":
|
|
logging.info("Modo de operación: ENCENDER MÁQUINAS\n")
|
|
group = 0
|
|
|
|
while group < len(vms):
|
|
logging.info("Grupo %s: PROCESANDO", group)
|
|
|
|
# Create the thread pool
|
|
n_threads = len(vms[group])
|
|
with ThreadPoolExecutor(n_threads) as executor:
|
|
_ = [executor.submit(power_on_vm, client, get_vm(
|
|
client, vm_name), vm_name) for vm_name in vms[group]]
|
|
|
|
# Terminado el grupo de máquinas
|
|
logging.info("Grupo %s: TERMINADO\n", group)
|
|
|
|
# Resumen
|
|
logging.info("Grupo %s: RESUMEN", group)
|
|
num_mv = 0
|
|
for vm_name in vms[group]:
|
|
vm = get_vm(client, vm_name)
|
|
if power_on_vm(client, vm, vm_name):
|
|
num_mv += 1
|
|
logging.info("%s de %s máquinas encendidas\n",
|
|
num_mv, len(vms[group]))
|
|
|
|
group += 1
|
|
if group < len(vms):
|
|
logging.info("Esperando %s segundos ...\n", wait_power_on)
|
|
time.sleep(wait_power_on)
|
|
|
|
# Apaga máquinas
|
|
if operation == "off":
|
|
logging.info("Modo de operación: APAGAR MÁQUINAS\n")
|
|
group = len(vms) - 1
|
|
|
|
while group >= 0:
|
|
logging.info("Grupo %s: PROCESANDO", group)
|
|
|
|
# Create the thread pool
|
|
n_threads = len(vms[group])
|
|
with ThreadPoolExecutor(n_threads) as executor:
|
|
_ = [executor.submit(power_off_vm, client, get_vm(
|
|
client, vm_name), vm_name) for vm_name in vms[group]]
|
|
|
|
# Terminado el grupo de máquinas
|
|
logging.info("Grupo %s: TERMINADO\n", group)
|
|
|
|
# Resumen
|
|
logging.info("Grupo %s: RESUMEN", group)
|
|
num_mv = 0
|
|
for vm_name in vms[group]:
|
|
vm = get_vm(client, vm_name)
|
|
if power_off_vm(client, vm, vm_name):
|
|
num_mv += 1
|
|
logging.info("%s de %s máquinas apagadas\n",
|
|
num_mv, len(vms[group]))
|
|
|
|
group -= 1
|
|
if group >= 0:
|
|
logging.info("Esperando %s segundos ...\n", wait_power_off)
|
|
time.sleep(wait_power_off)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|