opengnsys
/
ogclone-engine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request 'Finish boot lib' (#5) from bootlib into main 

Reviewed-on: #5
pull/6/head
Natalia Serrano 2025-03-19 11:32:39 +01:00
parent 0548aaa104 caec7bfc08
commit 7d0dafc2a9
41 changed files with 1584 additions and 456 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
ogclient/functions/ogBoot 100755
View File

@ -0,0 +1,45 @@
#!/usr/bin/python3
import sys
import argparse
from SystemLib import ogHelp
from BootLib import ogBoot
if 2 == len (sys.argv) and 'help' == sys.argv[1]:
#parser.print_help() sale en inglés aunque la locale indique otra cosa
ogHelp ('ogBoot', 'ogBoot int_ndisk int_nfilesys [ NVRAMPERM ] [str_kernel str_initrd str_kernelparams]', ['ogBoot 1 2 "/boot/vmlinuz /boot/initrd.img root=/dev/sda2 ro"', 'ogBoot 1 2 NVRAMPERM'])
sys.exit (0)
parser = argparse.ArgumentParser (add_help=False)
if 3 == len (sys.argv):
parser.add_argument ('disk')
parser.add_argument ('par')
elif 4 == len (sys.argv):
parser.add_argument ('disk')
parser.add_argument ('par')
parser.add_argument ('nvramperm_or_params')
elif 5 == len (sys.argv):
parser.add_argument ('disk')
parser.add_argument ('par')
parser.add_argument ('nvramperm')
parser.add_argument ('params')
args = parser.parse_args()
if 3 == len (sys.argv):
ret = ogBoot (args.disk, args.par)
elif 4 == len (sys.argv):
if 'NVRAMPERM' == args.nvramperm_or_params.upper():
nvramperm = True
params = ''
else:
nvramperm = False
params = args.nvramperm_or_params
ret = ogBoot (args.disk, args.par, nvramperm, params)
elif 5 == len (sys.argv):
ret = ogBoot (args.disk, args.par, not not args.nvramperm, args.params)
if ret is not None:
if ret == True: sys.exit (0)
elif ret == False: sys.exit (1)
else: print (ret)

26
ogclient/functions/ogBootLoaderDefaultEntry 100755
View File

@ -0,0 +1,26 @@
#!/usr/bin/python3
import sys
import argparse
import ogGlobals
from SystemLib import ogHelp
from BootLib import ogBootLoaderDefaultEntry
parser = argparse.ArgumentParser (add_help=False)
parser.add_argument ('disk')
parser.add_argument ('par')
parser.add_argument ('diskdefault')
parser.add_argument ('pardefault')
if 2 == len (sys.argv) and 'help' == sys.argv[1]:
#parser.print_help() sale en inglés aunque la locale indique otra cosa
ogHelp ('ogBootLoaderDefaultEntry', ogGlobals.lang.MSG_SEE+' ogGrubDefaultEntry', [])
sys.exit (0)
args = parser.parse_args()
ret = ogBootLoaderDefaultEntry (args.disk, args.par, args.diskdefault, args.pardefault)
if ret is not None:
if ret == True: sys.exit (0)
elif ret == False: sys.exit (1)
else: print (ret)

26
ogclient/functions/ogBootLoaderDeleteEntry 100755
View File

@ -0,0 +1,26 @@
#!/usr/bin/python3
import sys
import argparse
import ogGlobals
from SystemLib import ogHelp
from BootLib import ogBootLoaderDeleteEntry
parser = argparse.ArgumentParser (add_help=False)
parser.add_argument ('disk')
parser.add_argument ('par')
parser.add_argument ('diskdel')
parser.add_argument ('pardel')
if 2 == len (sys.argv) and 'help' == sys.argv[1]:
#parser.print_help() sale en inglés aunque la locale indique otra cosa
ogHelp ('ogBootLoaderDeleteEntry', ogGlobals.lang.MSG_SEE+' ogGrubDeleteEntry', [])
sys.exit (0)
args = parser.parse_args()
ret = ogBootLoaderDeleteEntry (args.disk, args.par, args.diskdel, args.pardel)
if ret is not None:
if ret == True: sys.exit (0)
elif ret == False: sys.exit (1)
else: print (ret)

33
ogclient/functions/ogBootLoaderHidePartitions 100755
View File

@ -0,0 +1,33 @@
#!/usr/bin/python3
import sys
import argparse
import ogGlobals
from SystemLib import ogHelp
from BootLib import ogBootLoaderHidePartitions
if 2 == len (sys.argv) and 'help' == sys.argv[1]:
#parser.print_help() sale en inglés aunque la locale indique otra cosa
ogHelp ('ogBootLoaderHidePartitions', ogGlobals.lang.MSG_SEE+' ogGrubHidePartitions', [])
sys.exit (0)
parser = argparse.ArgumentParser (add_help=False)
if 3 == len (sys.argv):
parser.add_argument ('disk')
parser.add_argument ('par')
elif 5 == len (sys.argv):
parser.add_argument ('disk')
parser.add_argument ('par')
parser.add_argument ('datadisk')
parser.add_argument ('datapar')
args = parser.parse_args()
if 3 == len (sys.argv):
ret = ogBootLoaderHidePartitions (args.disk, args.par)
elif 5 == len (sys.argv):
ret = ogBootLoaderHidePartitions (args.disk, args.par, args.datadisk, args.datapar)
if ret is not None:
if ret == True: sys.exit (0)
elif ret == False: sys.exit (1)
else: print (ret)

24
ogclient/functions/ogBootLoaderOgliveDefaultEntry 100755
View File

@ -0,0 +1,24 @@
#!/usr/bin/python3
import sys
import argparse
import ogGlobals
from SystemLib import ogHelp
from BootLib import ogBootLoaderOgliveDefaultEntry
parser = argparse.ArgumentParser (add_help=False)
parser.add_argument ('disk')
parser.add_argument ('par')
if 2 == len (sys.argv) and 'help' == sys.argv[1]:
#parser.print_help() sale en inglés aunque la locale indique otra cosa
ogHelp ('ogBootLoaderOgliveDefaultEntry', ogGlobals.lang.MSG_SEE+' ogGrubOgliveDefaultEntry', [])
sys.exit (0)
args = parser.parse_args()
ret = ogBootLoaderOgliveDefaultEntry (args.disk, args.par)
if ret is not None:
if ret == True: sys.exit (0)
elif ret == False: sys.exit (1)
else: print (ret)

25
ogclient/functions/ogBootLoaderSetTimeOut 100755
View File

@ -0,0 +1,25 @@
#!/usr/bin/python3
import sys
import argparse
import ogGlobals
from SystemLib import ogHelp
from BootLib import ogBootLoaderSetTimeOut
parser = argparse.ArgumentParser (add_help=False)
parser.add_argument ('disk')
parser.add_argument ('par')
parser.add_argument ('timeout')
if 2 == len (sys.argv) and 'help' == sys.argv[1]:
#parser.print_help() sale en inglés aunque la locale indique otra cosa
ogHelp ('ogBootLoaderSetTimeOut', ogGlobals.lang.MSG_SEE+' ogGrubSetTimeOut', [])
sys.exit (0)
args = parser.parse_args()
ret = ogBootLoaderSetTimeOut (args.disk, args.par, args.timeout)
if ret is not None:
if ret == True: sys.exit (0)
elif ret == False: sys.exit (1)
else: print (ret)

22
ogclient/functions/ogBootMbrGeneric 100755
View File

@ -0,0 +1,22 @@
#!/usr/bin/python3
import sys
import argparse
from SystemLib import ogHelp
from BootLib import ogBootMbrGeneric
parser = argparse.ArgumentParser (add_help=False)
parser.add_argument ('disk')
if 2 == len (sys.argv) and 'help' == sys.argv[1]:
#parser.print_help() sale en inglés aunque la locale indique otra cosa
ogHelp ('ogBootMbrGeneric', 'ogBootMbrGeneric int_ndisk', ['ogBootMbrGeneric 1'])
sys.exit (0)
args = parser.parse_args()
ret = ogBootMbrGeneric (args.disk)
if ret is not None:
if ret == True: sys.exit (0)
elif ret == False: sys.exit (1)
else: print (ret)

22
ogclient/functions/ogBootMbrXP 100755
View File

@ -0,0 +1,22 @@
#!/usr/bin/python3
import sys
import argparse
from SystemLib import ogHelp
from BootLib import ogBootMbrXP
parser = argparse.ArgumentParser (add_help=False)
parser.add_argument ('disk')
if 2 == len (sys.argv) and 'help' == sys.argv[1]:
#parser.print_help() sale en inglés aunque la locale indique otra cosa
ogHelp ('ogBootMbrXP', 'ogBootMbrXP int_ndisk', ['ogBootMbrXP 1'])
sys.exit (0)
args = parser.parse_args()
ret = ogBootMbrXP (args.disk)
if ret is not None:
if ret == True: sys.exit (0)
elif ret == False: sys.exit (1)
else: print (ret)

3
ogclient/functions/ogChangeRepo
View File

@ -7,7 +7,6 @@ from NetLib import ogChangeRepo
parser = argparse.ArgumentParser (add_help=False) parser = argparse.ArgumentParser (add_help=False)
parser.add_argument ('ip_repo') parser.add_argument ('ip_repo')
parser.add_argument ('og_unit', nargs='?', default=None)
if 2 == len (sys.argv) and 'help' == sys.argv[1]: if 2 == len (sys.argv) and 'help' == sys.argv[1]:
#parser.print_help() sale en inglés aunque la locale indique otra cosa #parser.print_help() sale en inglés aunque la locale indique otra cosa
@ -16,7 +15,7 @@ if 2 == len (sys.argv) and 'help' == sys.argv[1]:
args = parser.parse_args() args = parser.parse_args()
ret = ogChangeRepo (args.ip_repo, args.og_unit) ret = ogChangeRepo (args.ip_repo)
if ret is not None: if ret is not None:
if ret == True: sys.exit (0) if ret == True: sys.exit (0)
elif ret == False: sys.exit (1) elif ret == False: sys.exit (1)

22
ogclient/functions/ogGetBootMbr 100755
View File

@ -0,0 +1,22 @@
#!/usr/bin/python3
import sys
import argparse
from SystemLib import ogHelp
from BootLib import ogGetBootMbr
parser = argparse.ArgumentParser (add_help=False)
parser.add_argument ('disk')
if 2 == len (sys.argv) and 'help' == sys.argv[1]:
#parser.print_help() sale en inglés aunque la locale indique otra cosa
ogHelp ('ogGetBootMbr', 'ogGetBootMbr int_ndisk', ['ogGetBootMbr 1'])
sys.exit (0)
args = parser.parse_args()
ret = ogGetBootMbr (args.disk)
if ret is not None:
if ret == True: sys.exit (0)
elif ret == False: sys.exit (1)
else: print (ret)

23
ogclient/functions/ogGetWindowsName 100755
View File

@ -0,0 +1,23 @@
#!/usr/bin/python3
import sys
import argparse
from SystemLib import ogHelp
from BootLib import ogGetWindowsName
parser = argparse.ArgumentParser (add_help=False)
parser.add_argument ('disk')
parser.add_argument ('par')
if 2 == len (sys.argv) and 'help' == sys.argv[1]:
#parser.print_help() sale en inglés aunque la locale indique otra cosa
ogHelp ('ogGetWindowsName', 'ogGetWindowsName int_ndisk int_npartition', ['ogGetWindowsName 1 1'])
sys.exit (0)
args = parser.parse_args()
ret = ogGetWindowsName (args.disk, args.par)
if ret is not None:
if ret == True: sys.exit (0)
elif ret == False: sys.exit (1)
else: print (ret)

23
ogclient/functions/ogGrub4dosInstallMbr 100755
View File

@ -0,0 +1,23 @@
#!/usr/bin/python3
import sys
import argparse
from SystemLib import ogHelp
from BootLib import ogGrub4dosInstallMbr
parser = argparse.ArgumentParser (add_help=False)
parser.add_argument ('disk')
parser.add_argument ('par')
if 2 == len (sys.argv) and 'help' == sys.argv[1]:
#parser.print_help() sale en inglés aunque la locale indique otra cosa
ogHelp ('ogGrub4dosInstallMbr', 'ogGrub4dosInstallMbr int_ndisk int_part', ['ogGrub4dosInstallMbr 1 1'])
sys.exit (0)
args = parser.parse_args()
ret = ogGrub4dosInstallMbr (args.disk, args.par)
if ret is not None:
if ret == True: sys.exit (0)
elif ret == False: sys.exit (1)
else: print (ret)

25
ogclient/functions/ogGrubAddOgLive 100755
View File

@ -0,0 +1,25 @@
#!/usr/bin/python3
import sys
import argparse
from SystemLib import ogHelp
from BootLib import ogGrubAddOgLive
parser = argparse.ArgumentParser (add_help=False)
parser.add_argument ('disk')
parser.add_argument ('par')
parser.add_argument ('timeout', nargs='?')
parser.add_argument ('offline', nargs='?')
if 2 == len (sys.argv) and 'help' == sys.argv[1]:
#parser.print_help() sale en inglés aunque la locale indique otra cosa
ogHelp ('ogGrubAddOgLive', 'ogGrubAddOgLive int_ndisk int_npartition [ time_out ] [ offline|online ]', ['ogGrubAddOgLive 1 1', 'ogGrubAddOgLive 1 6 15 offline'])
sys.exit (0)
args = parser.parse_args()
ret = ogGrubAddOgLive (args.disk, args.par, args.timeout, args.offline)
if ret is not None:
if ret == True: sys.exit (0)
elif ret == False: sys.exit (1)
else: print (ret)

25
ogclient/functions/ogGrubDefaultEntry 100755
View File

@ -0,0 +1,25 @@
#!/usr/bin/python3
import sys
import argparse
from SystemLib import ogHelp
from BootLib import ogGrubDefaultEntry
parser = argparse.ArgumentParser (add_help=False)
parser.add_argument ('disk')
parser.add_argument ('par')
parser.add_argument ('diskdefault')
parser.add_argument ('pardefault')
if 2 == len (sys.argv) and 'help' == sys.argv[1]:
#parser.print_help() sale en inglés aunque la locale indique otra cosa
ogHelp ('ogGrubDefaultEntry', 'ogGrubDefaultEntry int_ndisk int_npartition int_disk_default_entry int_npartition_default_entry', ['ogGrubDefaultEntry 1 6 1 1'])
sys.exit (0)
args = parser.parse_args()
ret = ogGrubDefaultEntry (args.disk, args.par, args.diskdefault, args.pardefault)
if ret is not None:
if ret == True: sys.exit (0)
elif ret == False: sys.exit (1)
else: print (ret)

25
ogclient/functions/ogGrubDeleteEntry 100755
View File

@ -0,0 +1,25 @@
#!/usr/bin/python3
import sys
import argparse
from SystemLib import ogHelp
from BootLib import ogGrubDeleteEntry
parser = argparse.ArgumentParser (add_help=False)
parser.add_argument ('disk')
parser.add_argument ('par')
parser.add_argument ('diskdel')
parser.add_argument ('pardel')
if 2 == len (sys.argv) and 'help' == sys.argv[1]:
#parser.print_help() sale en inglés aunque la locale indique otra cosa
ogHelp ('ogGrubDeleteEntry', 'ogGrubDeleteEntry int_ndisk int_npartition int_disk_delete int_npartition_delete', ['ogGrubDeleteEntry 1 6 2 1'])
sys.exit (0)
args = parser.parse_args()
ret = ogGrubDeleteEntry (args.disk, args.par, args.diskdel, args.pardel)
if ret is not None:
if ret == True: sys.exit (0)
elif ret == False: sys.exit (1)
else: print (ret)

33
ogclient/functions/ogGrubHidePartitions 100755
View File

@ -0,0 +1,33 @@
#!/usr/bin/python3
import sys
import argparse
import ogGlobals
from SystemLib import ogHelp
from BootLib import ogGrubHidePartitions
if 2 == len (sys.argv) and 'help' == sys.argv[1]:
#parser.print_help() sale en inglés aunque la locale indique otra cosa
ogHelp ('ogGrubHidePartitions', 'ogGrubHidePartitions int_ndisk int_npartition [ num_disk_partdata num_partdata ]', ['ogGrubHidePartitions 1 2', 'ogGrubHidePartitions 1 2 1 3'])
sys.exit (0)
parser = argparse.ArgumentParser (add_help=False)
if 3 == len (sys.argv):
parser.add_argument ('disk')
parser.add_argument ('par')
elif 5 == len (sys.argv):
parser.add_argument ('disk')
parser.add_argument ('par')
parser.add_argument ('datadisk')
parser.add_argument ('datapar')
args = parser.parse_args()
if 3 == len (sys.argv):
ret = ogGrubHidePartitions (args.disk, args.par)
elif 5 == len (sys.argv):
ret = ogGrubHidePartitions (args.disk, args.par, args.datadisk, args.datapar)
if ret is not None:
if ret == True: sys.exit (0)
elif ret == False: sys.exit (1)
else: print (ret)

23
ogclient/functions/ogGrubOgliveDefaultEntry 100755
View File

@ -0,0 +1,23 @@
#!/usr/bin/python3
import sys
import argparse
from SystemLib import ogHelp
from BootLib import ogGrubOgliveDefaultEntry
parser = argparse.ArgumentParser (add_help=False)
parser.add_argument ('disk')
parser.add_argument ('par')
if 2 == len (sys.argv) and 'help' == sys.argv[1]:
#parser.print_help() sale en inglés aunque la locale indique otra cosa
ogHelp ('ogGrubOgliveDefaultEntry', 'ogGrubOgliveDefaultEntry int_ndiskSecondStage int_partitionSecondStage', ['ogGrubOgliveDefaultEntry 1 6'])
sys.exit (0)
args = parser.parse_args()
ret = ogGrubOgliveDefaultEntry (args.disk, args.par)
if ret is not None:
if ret == True: sys.exit (0)
elif ret == False: sys.exit (1)
else: print (ret)

25
ogclient/functions/ogGrubSecurity 100755
View File

@ -0,0 +1,25 @@
#!/usr/bin/python3
import sys
import argparse
from SystemLib import ogHelp
from BootLib import ogGrubSecurity
parser = argparse.ArgumentParser (add_help=False)
parser.add_argument ('disk')
parser.add_argument ('par')
parser.add_argument ('user', nargs='?', default='root')
parser.add_argument ('passwd', nargs='?', default='')
if 2 == len (sys.argv) and 'help' == sys.argv[1]:
#parser.print_help() sale en inglés aunque la locale indique otra cosa
ogHelp ('ogGrubSecurity', 'ogGrubSecurity int_ndiskSecondStage int_partitionSecondStage [USER] [PASSWORD]', ['ogGrubSecurity 1 1', 'ogGrubSecurity 1 2 user clave'])
sys.exit (0)
args = parser.parse_args()
ret = ogGrubSecurity (args.disk, args.par, args.user, args.passwd)
if ret is not None:
if ret == True: sys.exit (0)
elif ret == False: sys.exit (1)
else: print (ret)

24
ogclient/functions/ogGrubSetTimeOut 100755
View File

@ -0,0 +1,24 @@
#!/usr/bin/python3
import sys
import argparse
from SystemLib import ogHelp
from BootLib import ogGrubSetTimeOut
parser = argparse.ArgumentParser (add_help=False)
parser.add_argument ('disk')
parser.add_argument ('par')
parser.add_argument ('timeout')
if 2 == len (sys.argv) and 'help' == sys.argv[1]:
#parser.print_help() sale en inglés aunque la locale indique otra cosa
ogHelp ('ogGrubSetTimeOut', 'ogGrubSetTimeOut int_ndiskSecondStage int_partitionSecondStage int_timeout_seconds', ['ogGrubSetTimeOut 1 4 50'])
sys.exit (0)
args = parser.parse_args()
ret = ogGrubSetTimeOut (args.disk, args.par, args.timeout)
if ret is not None:
if ret == True: sys.exit (0)
elif ret == False: sys.exit (1)
else: print (ret)

23
ogclient/functions/ogLinuxBootParameters 100755
View File

@ -0,0 +1,23 @@
#!/usr/bin/python3
import sys
import argparse
from SystemLib import ogHelp
from BootLib import ogLinuxBootParameters
parser = argparse.ArgumentParser (add_help=False)
parser.add_argument ('disk')
parser.add_argument ('par')
if 2 == len (sys.argv) and 'help' == sys.argv[1]:
#parser.print_help() sale en inglés aunque la locale indique otra cosa
ogHelp ('ogLinuxBootParameters', 'ogLinuxBootParameters int_ndisk int_nfilesys', ['ogLinuxBootParameters 1 2'])
sys.exit (0)
args = parser.parse_args()
ret = ogLinuxBootParameters (args.disk, args.par)
if ret is not None:
if ret == True: sys.exit (0)
elif ret == False: sys.exit (1)
else: print (ret)

37
ogclient/functions/ogSetLinuxName 100755
View File

@ -0,0 +1,37 @@
#!/usr/bin/python3
import sys
import argparse
from SystemLib import ogHelp
from BootLib import ogSetLinuxName
from NetLib import ogGetHostname
if 2 == len (sys.argv) and 'help' == sys.argv[1]:
#parser.print_help() sale en inglés aunque la locale indique otra cosa
ogHelp ('ogSetLinuxName', 'ogSetLinuxName int_ndisk int_nfilesys [str_name]', ['ogSetLinuxName 1 1 practica-pc'])
sys.exit (0)
parser = argparse.ArgumentParser (add_help=False)
if 3 == len (sys.argv):
parser.add_argument ('disk')
parser.add_argument ('par')
elif 4 == len (sys.argv):
parser.add_argument ('disk')
parser.add_argument ('par')
parser.add_argument ('hostname')
args = parser.parse_args()
if 3 == len (sys.argv):
h = ogGetHostname()
if h:
ret = ogSetLinuxName (args.disk, args.par, h)
else:
ret = ogSetLinuxName (args.disk, args.par)
elif 4 == len (sys.argv):
ret = ogSetLinuxName (args.disk, args.par, args.hostname)
if ret is not None:
if ret == True: sys.exit (0)
elif ret == False: sys.exit (1)
else: print (ret)

24
ogclient/functions/ogSetWinlogonUser 100755
View File

@ -0,0 +1,24 @@
#!/usr/bin/python3
import sys
import argparse
from SystemLib import ogHelp
from BootLib import ogSetWinlogonUser
parser = argparse.ArgumentParser (add_help=False)
parser.add_argument ('disk')
parser.add_argument ('par')
parser.add_argument ('username')
if 2 == len (sys.argv) and 'help' == sys.argv[1]:
#parser.print_help() sale en inglés aunque la locale indique otra cosa
ogHelp ('ogSetWinlogonUser', 'ogSetWinlogonUser int_ndisk int_npartition str_username', ['ogSetWinlogonUser 1 1 USUARIO'])
sys.exit (0)
args = parser.parse_args()
ret = ogSetWinlogonUser (args.disk, args.par, args.username)
if ret is not None:
if ret == True: sys.exit (0)
elif ret == False: sys.exit (1)
else: print (ret)

11
ogclient/interfaceAdm/Apagar.py
View File

@ -1,10 +1,7 @@
#!/usr/bin/env python3 #!/usr/bin/python3
import os import os
import sys import sys
def main(): os.system ('poweroff')
os.system('poweroff') sys.exit (0)
sys.exit(0)
if __name__ == "__main__":
main()

100
ogclient/interfaceAdm/CambiarAcceso.py
View File

@ -1,54 +1,62 @@
#!/usr/bin/env python3 #!/usr/bin/python3
#______________________________________
#
# PARAMETROS RECIBIDOS DESDE EL CLIENTE
# $1 modo (admin, user)
#______________________________________
import os import os
import sys import sys
import re
import subprocess import subprocess
import NetLib
import SystemLib
def main(): import ogGlobals
if len(sys.argv) != 2: from SystemLib import ogEcho, ogRaiseError, ogIsRepoLocked
print("Usage: CambiarAcceso.py <mode>") from NetLib import ogGetRepoIp
sys.exit(1)
mode = sys.argv[1] # Error si llamada no se realliza desde OpenGnsys Client.
repo_ip = NetLib.ogGetRepoIp() prog = sys.argv[0]
if len (sys.argv) != 2:
print (f'Usage: {prog} <mode>')
sys.exit (1)
if not repo_ip: # Salir si el repositorio está bloquedo (tiene ficheros abiertos).
SystemLib.ogRaiseError("OG_ERR_NOTFOUND", "repo no montado") mode = sys.argv[1]
repoip = ogGetRepoIp()
if not repoip:
ogRaiseError ([], ogGlobals.OG_ERR_NOTFOUND, 'repo no montado')
sys.exit (1)
if ogIsRepoLocked():
ogRaiseError ([], ogGlobals.OG_ERR_LOCKED, f'repo {repoip}')
sys.exit (1)
if SystemLib.ogIsRepoLocked(): # Comprobar protocolo y modo de acceso.
SystemLib.ogRaiseError("OG_ERR_LOCKED", f"repo {repo_ip}") proto = os.getenv ('ogprotocol', 'smb')
if proto not in ['nfs', 'smb']:
ogRaiseError ([], ogGlobals.OG_ERR_FORMAT, f'protocolo desconocido {proto}')
sys.exit (1)
if 'admin' == mode: mount_mode = 'rw'
elif 'user' == mode: mount_mode = 'ro'
else:
ogRaiseError ([], ogGlobals.OG_ERR_FORMAT, f'modo desconocido {mode}')
sys.exit (1)
proto = os.getenv("ogprotocol", "smb") # Desmontar repositorio y volver a montarlo con el modo adecuado.
if proto not in ["nfs", "smb"]: subprocess.run (['umount', ogGlobals.OGIMG])
SystemLib.ogRaiseError("OG_ERR_FORMAT", f"protocolo desconocido {proto}") ogEcho ([], 'info', f'Montar repositorio {repoip} por {proto} en modo {mode}')
if 'nfs' == proto:
if mode == "admin": subprocess.run (['mount', '-t', 'nfs', f'{repoip}:{ogGlobals.OGIMG}', ogGlobals.OGIMG, '-o', mount_mode])
mount_mode = "rw" elif 'smb' == proto:
elif mode == "user": pass_option = ''
mount_mode = "ro" with open ('/scripts/ogfunctions', 'r') as fd:
else: while True:
SystemLib.ogRaiseError("OG_ERR_FORMAT", f"modo desconocido {mode}") line = fd.readline()
if not line: break
OGIMG = os.getenv("OGIMG", "/mnt/OGIMG") if not re.search ('^[\t ]*(export )?OPTIONS=', line): continue
OGUNIT = os.getenv("OGUNIT", "") m = re.search (r'pass=(\w*)', line)
if OGUNIT: if m:
OGUNIT = f"/{OGUNIT}" pass_option = m.groups (0)[0]
break
subprocess.run(["umount", OGIMG], check=True) if not pass_option: pass_option = 'og'
SystemLib.ogEcho("info", f"Montar repositorio {repo_ip} por {proto} en modo {mode}") subprocess.run (['mount.cifs', f'//{repoip}/ogimages', ogGlobals.OGIMG, '-o', f'{mount_mode},serverino,acl,username=opengnsys,password={pass_option}'])
if proto == "nfs":
subprocess.run(["mount", "-t", "nfs", f"{repo_ip}:{OGIMG}{OGUNIT}", OGIMG, "-o", mount_mode], check=True)
elif proto == "smb":
with open("/scripts/ogfunctions", "r") as f:
for line in f:
if "OPTIONS=" in line:
pass_option = line.split("pass=")[1].split()[0]
break
else:
pass_option = "og"
subprocess.run(["mount.cifs", f"//{repo_ip}/ogimages{OGUNIT}", OGIMG, "-o", f"{mount_mode},serverino,acl,username=opengnsys,password={pass_option}"], check=True)
if __name__ == "__main__":
main()

147
ogclient/interfaceAdm/CrearImagen.py
View File

@ -1,74 +1,109 @@
#!/usr/bin/env python3 #!/usr/bin/python3
#___________________________________________________
#
# PARAMETROS RECIBIDOS DESDE EL CLIENTE:
# $1 Número de disco
# $2 Número de particion
# $3 Nombre canónico de la imagen (sin extensión)
# $4 Dirección del repositorio (REPO, por defecto)
#___________________________________________________
#$OG_ERR_NOTEXEC Si no es llamada por OG client
#$OG_ERR_LOCKED=4 Si la particion está bloqueada.
#Codigos de error del scripts createImage
#@exception OG_ERR_FORMAT # 1 formato incorrecto.
#@exception OG_ERR_PARTITION # 3 Error en partición de disco o en su sistema de archivos
#@exception OG_ERR_IMAGE # 5 Error en funcion ogCreateImage o ogRestoreImage.
#@exception OG_ERR_NOTWRITE # 14 error de escritura
#@exception OG_ERR_NOTCACHE # 15 si cache no existe 15
#@exception OG_ERR_CACHESIZE # 16 si espacio de la cache local o remota no tiene espacio 16
#@exception OG_ERR_REDUCEFS # 17 error al reducir sistema de archivos.
#@exception OG_ERR_EXTENDFS # 18 Errror al expandir el sistema de archivos.
#Códigos de error de la funcion ogCreateImage
import os import os
import subprocess import subprocess
import sys import sys
import time import time
import NetLib
import ogGlobals import ogGlobals
from SystemLib import ogEcho, ogRaiseError
from NetLib import ogGetIpAddress, ogChangeRepo
from StringLib import ogCheckIpAddress
def load_engine_config(): prog = sys.argv[0]
engine_config_path = "/opt/opengnsys/etc/engine.cfg" if len (sys.argv) < 4:
if os.path.exists(engine_config_path): ogRaiseError ([], ogGlobals.OG_ERR_FORMAT, 'Incorrect number of arguments')
with open(engine_config_path) as f: sys.exit (1)
exec(f.read(), globals()) disk, par, imgname, *other = sys.argv[1:]
arg_repo = other[0] if len (other) > 0 else 'REPO'
dirname = os.path.dirname (prog)
def clear_temp_logs(): start_time = time.time()
open(os.getenv('OGLOGSESSION'), 'w').close() env_boot = os.getenv ('boot')
open(os.getenv('OGLOGCOMMAND'), 'w').close()
open(f"{os.getenv('OGLOGCOMMAND')}.tmp", 'w').close()
def log_session_start(script_name, args): #Load engine configurator from engine.cfg file.
SystemLib.ogEcho("log session", f"{os.getenv('MSG_INTERFACE_START')} {script_name} {' '.join(args)}") #Carga el configurador del engine desde el fichero engine.cfg
## (ogGlobals se encarga)
def log_session_end(retval): # Clear temporary file used as log track by httpdlog
SystemLib.ogEcho("log session", f"{os.getenv('MSG_INTERFACE_END')} {retval}") # Limpia los ficheros temporales usados como log de seguimiento para httpdlog
open (ogGlobals.OGLOGSESSION, 'w').close()
open (ogGlobals.OGLOGCOMMAND, 'w').close()
open (f"{ogGlobals.OGLOGCOMMAND}.tmp", 'w').close()
def ogCheckIpAddress(ip): # Registro de inicio de ejecución
try: ogEcho (['log', 'session'], None, f'{ogGlobals.lang.MSG_INTERFACE_START} {prog} {disk} {par} {imgname} {arg_repo}')
subprocess.check_call(["ping", "-c", "1", ip])
return 0
except subprocess.CalledProcessError:
return 1
def create_image(disk_num, partition_num, repo, image_name): # Valor por defecto para el repositorio.
if subprocess.call(["which", "createImageCustom"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) == 0: repo = arg_repo
return subprocess.call(["createImageCustom", disk_num, partition_num, repo, f"/{image_name}"]) if not repo: repo = 'REPO'
else: if repo == ogGetIpAddress(): repo = 'CACHE'
return subprocess.call(["createImage", disk_num, partition_num, repo, f"/{image_name}"]) # Si es una ip y es distinta a la del recurso samba cambiamos de REPO.
if 'REPO' == repo or StringLib.ogCheckIpAddress (repo):
# Si falla el cambio -> salimos con error repositorio no valido
if not ogChangeRepo (repo):
ogRaiseError ([], ogGlobals.OG_ERR_NOTFOUND, repo)
sys.exit (1)
def main(): # Si el destino es REPO y el cliente no está en modo "admin"; activar repositorio para escritura,
if len(sys.argv) != 5: if 'REPO' == repo and 'admin' != env_boot:
sys.exit(SystemLib.ogRaiseError(OG_ERR_FORMAT, "Incorrect number of arguments")) retval = subprocess.run ([f'{dirname}/CambiarAcceso.py', 'admin']).returncode
if retval:
sys.exit (retval)
disk_num, partition_num, image_name, repo = sys.argv[1:5] ogEcho ([], None, f'createImage "{disk}" "{par}" "{arg_repo}" /"{imgname}"')
# Si existe, ejecuta script personalizado "createImageCustom"; si no, llama al genérico "createImage".
if os.path.exists ('{ogGlobals.OGSCRIPTS}/createImageCustom.py'):
script = f'{ogGlobals.OGSCRIPTS}/createImageCustom.py'
else:
script = f'{ogGlobals.OGSCRIPTS}/createImage.py'
start_time = time.time() with open (ogGlobals.OGLOGCOMMAND, 'a') as fd:
p = subprocess.Popen ([script, disk, par, arg_repo, f'/{imgname}'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
while p.poll() is None:
for l in iter (p.stdout.readline, b''):
partial = l.decode ('utf-8', 'ignore')
fd.write (partial)
print (partial, end='') ## so that the agent captures out output and reports progress to ogcore
for l in iter (p.stderr.readline, b''):
partial = l.decode ('utf-8', 'ignore')
fd.write (partial)
print (partial, end='')
retval = p.returncode
load_engine_config() # Cambiar acceso a modo usuario, si es necesario.
clear_temp_logs() if 'REPO' == repo and 'admin' != env_boot:
log_session_start(sys.argv[0], sys.argv[1:]) subprocess.run ([f'{dirname}/CambiarAcceso.py', 'user'])
repo = repo if repo else "REPO" # Registro de fin de ejecución
if repo == NetLib.ogGetIpAddress(): ogEcho (['log', 'session'], None, f'{ogGlobals.lang.MSG_INTERFACE_END} {retval}')
repo = "CACHE"
if ogCheckIpAddress(repo) == 0 or repo == "REPO": sys.exit (retval)
OGUNIT = os.getenv('OGUNIT', "")
if not NetLib.ogChangeRepo(repo, OGUNIT):
sys.exit(SystemLib.ogRaiseError(OG_ERR_NOTFOUND, f"{repo}"))
if repo == "REPO" and os.getenv('boot') != "admin":
retval = CambiarAcceso("admin")
if retval > 0:
sys.exit(retval)
retval = create_image(disk_num, partition_num, repo, image_name)
if repo == "REPO" and os.getenv('boot') != "admin":
CambiarAcceso("user")
log_session_end(retval)
sys.exit(retval)
if __name__ == "__main__":
main()

78
ogclient/interfaceAdm/EjecutarScript.py
View File

@ -1,62 +1,50 @@
#!/usr/bin/env python3 #!/usr/bin/python3
import os import os
import time import time
import subprocess import subprocess
import sys import sys
import SystemLib
import ogGlobals import ogGlobals
from SystemLib import ogEcho, ogRaiseError
#sys.path.append('/opt/opengnsys/lib/engine/bin')
def main(script_path): prog = sys.argv[0]
start_time = time.time() if len (sys.argv) != 2:
print(f"Ejecutando:",script_path) print (f'Usage: {prog} <script_path>')
sys.exit (1)
# Load engine configurator from engine.cfg file. TIME1 = time.time()
engine_config_path = '/opt/opengnsys/etc/engine.cfg' script_path = sys.argv[1]
# if 'OGENGINECONFIGURATE' not in os.environ:
# with open(engine_config_path) as f:
# exec(f.read(), globals())
# Clear temporary file used as log track by httpdlog # Clear temporary file used as log track by httpdlog
with open(os.environ['OGLOGSESSION'], 'w') as f: # Limpia los ficheros temporales usados como log de seguimiento para httpdlog
f.write("") open (ogGlobals.OGLOGSESSION, 'w').close()
with open(os.environ['OGLOGCOMMAND'], 'w') as f: open (ogGlobals.OGLOGCOMMAND, 'w').close()
f.write("")
# Registro de inicio de ejecución # Registro de inicio de ejecución
SystemLib.ogEcho('log session', f"{os.environ['MSG_INTERFACE_START']} {sys.argv[0]} {' '.join(sys.argv[1:])}") ogEcho (['log', 'session'], None, f'{ogGlobals.lang.MSG_INTERFACE_START} {prog} {script_path}')
with open(os.environ['OGLOGFILE'], 'a') as log_file: with open (ogGlobals.OGLOGFILE, 'a') as logfd:
log_file.write("\n Instrucciones a ejecutar: *****************************\n" with open (script_path) as scriptfd:
with open(script_path.split()[1]) as script_file: # Obtener solo el nombre del script logfd.write ('\n Instrucciones a ejecutar: *****************************\n')
log_file.write(script_file.read()) ) logfd.write (scriptfd.read())
log_file.write("\n Salida de las instrucciones: *****************************\n") logfd.write ('\n Salida de las instrucciones: *****************************\n')
# Cambiar permisos y ejecutar el script os.chmod (script_path, 0o755)
os.chmod(script_path.split()[1], 0o755) # Si mandamos la salida a OGLOGCOMMAND reescribimos lo que manda el comando.
result = subprocess.run([sys.executable] + script_path.split(), capture_output=True, text=True) RETVAL = subprocess.run (script_path, capture_output=True, text=True).returncode
ret_val = result.returncode
with open(os.environ['OGLOGCOMMAND'], 'a') as log_command_file:
log_command_file.write(result.stdout)
log_command_file.write(result.stderr)
elapsed_time = time.time() - start_time TIME = time.time() - TIME1
if ret_val == 0: if 0 == RETVAL:
SystemLib.ogEcho('log session', f"[100] Duracion de la operacion {int(elapsed_time // 60)}m {int(elapsed_time % 60)}s") ogEcho (['log', 'session'], None, f'[100] Duracion de la operacion {int(TIME // 60)}m {int(TIME % 60)}s')
else: else:
SystemLib.ogRaiseError('log session', ret_val) ogRaiseError (['log', 'session'], RETVAL, '')
SystemLib.ogEcho('log session', 'error "Operacion no realizada"') ogEcho (['log', 'session'], 'error', 'Operacion no realizada')
# Registro de fin de ejecución # Registro de fin de ejecución
SystemLib.ogEcho('log session', f"{os.environ['MSG_INTERFACE_END']} {ret_val}") ogEcho (['log', 'session'], None, f'{ogGlobals.lang.MSG_INTERFACE_END} {RETVAL}')
sys.exit(ret_val) sys.exit (RETVAL)
if __name__ == "__main__":
if len(sys.argv) != 2:
print("Usage: python EjecutarScript.py <script_path>")
sys.exit(1)
main(sys.argv[1])

48
ogclient/interfaceAdm/InventarioHardware.py
View File

@ -1,33 +1,25 @@
#!/usr/bin/env python3 #!/usr/bin/python3
import subprocess # Script de interfaz para guardar en un fichero el inventario de hardware de un cliente.
import sys import sys
import subprocess
def main(output_file): import ogGlobals
# Ejecutar el comando `listHardwareInfo.py` y capturar el resultado from SystemLib import ogRaiseError
try:
print(f"------------------------------------------ loading listHardwareInfo.py")
result = subprocess.run(
["python3", "/opt/opengnsys/scripts/listHardwareInfo.py"],
capture_output=True, text=True, check=True
)
output_lines = result.stdout.strip().split('\n')
file_path = output_lines[-1] # Obtener la última línea como la ruta del archivo de salida
print(f"------------------------------------------ archivo:{file_path}")
# Leer desde la segunda línea del archivo y escribir en el archivo de salida especificado prog = sys.argv[0]
with open(file_path, 'r') as input_file, open(output_file, 'w') as output: if len (sys.argv) != 2:
lines = input_file.readlines()[1:] # Saltar la primera línea print (f'Usage: {prog} <output_file>')
output.writelines(lines) sys.exit (1)
output_file = sys.argv[1]
except subprocess.CalledProcessError as e: listhi_out = subprocess.run ( [f'{ogGlobals.OGSCRIPTS}/listHardwareInfo.py'], capture_output=True, text=True).stdout
print("Error ejecutando listHardwareInfo.py:", e.stderr, file=sys.stderr) if listhi_out:
sys.exit(e.returncode) inventory_path = listhi_out.splitlines()[0]
except FileNotFoundError as e: else:
print(f"Archivo no encontrado: {e.filename}", file=sys.stderr) ogRaiseError ([], ogGlobals.OG_ERR_GENERIC, 'listHardwareInfo.py failed')
sys.exit(1) sys.exit (1)
if __name__ == "__main__": with open (inventory_path, 'r') as fdin, open (output_file, 'w') as fdout:
if len(sys.argv) != 2: lines = fdin.readlines()[1:] # 'tail -n +2'
print("Uso: python3 InventarioHardware.py <archivo_salida>") fdout.writelines (lines)
sys.exit(1)
main(sys.argv[1])

73
ogclient/interfaceAdm/InventarioSoftware.py
View File

@ -1,53 +1,40 @@
#!/usr/bin/env python3 #!/usr/bin/env python3
import os import os
import time import time
import shutil import shutil
import subprocess import subprocess
import sys import sys
sys.path.append('/opt/opengnsys/lib/engine/bin')
import ogGlobals import ogGlobals
import SystemLib from SystemLib import ogEcho, ogRaiseError
def main(arg1, arg2, dest_file):
start_time = time.time()
og_log_session = os.getenv(ogGlobals.OGLOGSESSION)
og_log_command = os.getenv(ogGlobals.OGLOGCOMMAND)
if og_log_session and og_log_command:
with open(og_log_session, 'w') as f:
f.write(" ")
with open(og_log_command, 'w') as f:
f.write(" ")
with open(f"{og_log_command}.tmp", 'w') as f:
f.write(" ")
msg_interface_start = os.getenv(ogGlobals.lang.MSG_INTERFACE_START)
if msg_interface_start:
SystemLib.ogEcho("log", "session", f"{msg_interface_start} {__file__} {arg1} {arg2}")
try:
result = subprocess.run(
["python3", "/opt/opengnsys/scripts/listSoftwareInfo.py", arg1, arg2],
capture_output=True,
text=True,
check=True
)
file = result.stdout.strip().splitlines()[-1]
except subprocess.CalledProcessError as e:
print(f"Error al ejecutar listSoftwareInfo: {e.stderr}")
sys.exit(e.returncode)
print(f"Copying:( {file} to {dest_file} )")
shutil.copy(file, dest_file)
elapsed_time = time.time() - start_time
msg_scripts_time_partial = os.getenv(ogGlobals.lang.MSG_SCRIPTS_TIME_PARTIAL)
if msg_scripts_time_partial:
SystemLib.ogEcho("log", "session", f" [ ] {msg_scripts_time_partial} : {int(elapsed_time // 60)}m {int(elapsed_time % 60)}s")
if __name__ == "__main__": if __name__ == "__main__":
if len(sys.argv) != 4: prog = sys.argv[0]
print("Usage: python InventarioSoftware.py <arg1> <arg2> <dest_file>") if len (sys.argv) != 4:
sys.exit(1) print (f'Usage: {prog} <disk> <partition> <dest_file>')
main(sys.argv[1], sys.argv[2], sys.argv[3]) sys.exit (1)
disk, par, dest_file = sys.argv[1:]
TIME1 = time.time()
# Limpia los ficheros temporales usados como log de seguimiento para httpdlog
open (ogGlobals.OGLOGSESSION, 'w').close()
open (ogGlobals.OGLOGCOMMAND, 'w').close()
open (f"{ogGlobals.OGLOGCOMMAND}.tmp", 'w').close()
# Registro de inicio de ejecución
ogEcho (['log', 'session'], None, f'{ogGlobals.lang.MSG_INTERFACE_START} {prog} {disk} {par} {dest_file}')
listsi_out = subprocess.run ([f'{ogGlobals.OGSCRIPTS}/listSoftwareInfo.py', disk, par], capture_output=True, text=True).stdout
if listsi_out:
file = listsi_out.splitlines()[0]
else:
ogRaiseError ([], ogGlobals.OG_ERR_GENERIC, 'listSoftwareInfo.py failed')
sys.exit (1)
shutil.copy (file, dest_file)
TIME = time.time() - TIME1
ogEcho(['log', 'session'], None, f' [ ] {ogGlobals.lang.MSG_SCRIPTS_TIME_PARTIAL} : {int(TIME // 60)}m {int(TIME % 60)}s')

11
ogclient/interfaceAdm/Reiniciar.py
View File

@ -1,8 +1,7 @@
#!/usr/bin/env python3 #!/usr/bin/python3
import os import os
import sys
def reboot_system(): os.system ('reboot')
os.system('reboot') sys.exit (0)
if __name__ == "__main__":
reboot_system()

38
ogclient/interfaceAdm/RestaurarImagen.py
View File

@ -1,19 +1,29 @@
#!/usr/bin/env python3 #!/usr/bin/python3
#_______________________________________________________________________________________________________________________________
#
# PARAMETROS RECIBIDOS DESDE EL CLIENTE:
# $1 disco
# $2 par=Número de particion
# $3 Nombre canónico de la imagen
# $4 Dirección IP del repositorio
# $5 Protocolo UNICAST MULTICAST TORRENT
# $6 Opciones del protocolo
#_______________________________________________________________________________________________________________________________
# Llamar al script de despliegue "deployImage".
import sys import sys
import subprocess import subprocess
if __name__ == "__main__": import ogGlobals
if len(sys.argv) < 7:
print("Usage: python RestaurarImagen.py <disk> <partition> <image_name> <ip> <protocol> <protocol_options> [additional_args...]")
sys.exit(1)
disk = sys.argv[1] if __name__ == '__main__':
partition = sys.argv[2] prog = sys.argv[0]
image_name = sys.argv[3] if len (sys.argv) < 7:
ip = sys.argv[4] print (f'Usage: {prog} <disk> <partition> <image_name> <repo_ip> <protocol> <protocol_options> [additional_args...]')
protocol = sys.argv[5] sys.exit (1)
protocol_options = sys.argv[6]
additional_args = sys.argv[7:]
exit_code = deploy_image(ip, image_name, disk, partition, protocol, protocol_options, *additional_args) disk, par, imgname, repo, proto, protoopt, *extra = sys.argv[1:]
sys.exit(exit_code)
rc = subprocess.run ([f'{ogGlobals.OGSCRIPTS}/deployImage.py', repo, imgname, disk, par, proto, protoopt] + extra).returncode
sys.exit (rc)

807
ogclient/lib/python3/BootLib.py
View File

@ -12,6 +12,7 @@ import tempfile
import subprocess import subprocess
import shutil import shutil
import glob import glob
import inspect
import ogGlobals import ogGlobals
import SystemLib import SystemLib
@ -21,6 +22,7 @@ import DiskLib
import InventoryLib import InventoryLib
import FileLib import FileLib
import UEFILib import UEFILib
import CacheLib
#/** #/**
# ogBoot int_ndisk int_nfilesys [ NVRAMPERM ] [str_kernel str_initrd str_krnlparams] # ogBoot int_ndisk int_nfilesys [ NVRAMPERM ] [str_kernel str_initrd str_krnlparams]
@ -37,6 +39,168 @@ import UEFILib
#@note En Linux, si no se indican los parámetros de arranque se detectan de la opción por defecto del cargador GRUB. #@note En Linux, si no se indican los parámetros de arranque se detectan de la opción por defecto del cargador GRUB.
#@note En Linux, debe arrancarse la partición del directorio \c /boot #@note En Linux, debe arrancarse la partición del directorio \c /boot
#*/ ## #*/ ##
def ogBoot (disk, par, nvramperm=False, params=''):
# Detectar tipo de sistema de archivos y montarlo.
part = DiskLib.ogDiskToDev (disk, par)
if not part: return None
type = InventoryLib.ogGetOsType (disk, par)
if not type: return None
# Error si no puede montar sistema de archivos.
mntdir = FileSystemLib.ogMount (disk, par)
if not mntdir: return None
#params = None
#if 'NVRAMPERM' == nvramperm.upper():
# nvramperm = True
#else:
# params = nvramperm
# nvramperm = False
if 'Linux' == type or 'Android' == type:
# Si no se indican, obtiene los parámetros de arranque para Linux.
if not params:
params = ogLinuxBootParameters (disk, par)
# Si no existe y el UEFI buscar en particion ESP
if not params and InventoryLib.ogIsEfiActive():
esp = DiskLib.ogGetEsp()
efidisk, efipart = esp.split()
params = ogLinuxBootParameters (efidisk, efipart)
params += ' ' + esp
# Si no existe, buscar sistema de archivo /boot en /etc/fstab.
if not params and os.path.exists (f'{mntdir}/etc/fstab'):
# Localizar S.F. /boot en /etc/fstab del S.F. actual.
dev = None
with open (f'{mntdir}/etc/fstab', 'r') as fd:
while True:
l = fd.readline()
if not l: break
parts = l.split()
if '#' != parts[0] and '/boot' == parts[1]:
dev = parts[0]
break
if dev:
fstab_part = DiskLib.ogDevToDisk (dev)
else:
return None
# Montar S.F. de /boot.
fstab_disk, fstab_par = fstab_part.split()
mntdir = FileSystemLib.ogMount (fstab_disk, fstab_par)
if not mntdir: return None
# Buscar los datos de arranque.
params = ogLinuxBootParameters (fstab_disk, fstab_par)
kernel = initrd = append = None
if params:
kernel, initrd, append = params.split (maxsplit=2)
# Si no hay kernel, no hay sistema operativo.
if not kernel or not os.path.exists (f'{mntdir}/{kernel}'):
SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_NOTOS, f'{disk} {par} ({type})')
return None
# Arrancar de partición distinta a la original.
if os.path.exists (f'{mntdir}/etc'):
append = re.sub ('root=[-+=_/a-zA-Z0-9]* ', f'root={part} ', append)
# Comprobar tipo de sistema.
if InventoryLib.ogIsEfiActive():
# Comprobar si el Kernel está firmado.
file_out = subprocess.run (['file', '-k', f'{mntdir}/{kernel}'], capture_output=True, text=True).stdout
if not file_out or not 'EFI app' in file_out:
SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_NOTOS, f'{disk} {par} ({type}, EFI)')
return None
bootlabel = f'Part-{int(disk):02d}-{int(par):02d}'
bootloader = 'shimx64.efi'
# Obtener parcición EFI.
esp = DiskLib.ogGetEsp()
#efidisk, efipart = esp.split()
# TODO: Comprobamos que existe la BOOTLABEL, si no buscamos por sistema operativo
if '' == FileLib.ogGetPath (src=esp, file=f'EFI/{bootlabel}'):
osversion = InventoryLib.ogGetOsVersion (disk, par)
if 'SUSE' in osversion:
bootlabel = 'opensuse'
elif 'Fedora' in osversion:
bootlabel = 'fedora'
elif 'Ubuntu' in osversion:
bootlabel = 'ubuntu'
else:
SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_NOTFOUND, f'{esp} Boot loader')
return None
# Crear orden de arranque (con unos valores por defecto).
UEFILib.ogNvramAddEntry (bootlabel, f'/EFI/{bootlabel}/Boot/{bootloader}', nvramperm)
# Marcar próximo arranque y reiniciar.
UEFILib.ogNvramSetNext (bootlabel)
subprocess.run (['reboot'])
else:
# Arranque BIOS: configurar kernel Linux con los parámetros leídos de su GRUB.
subprocess.run (['kexec', '-l', f'{mntdir}{kernel}', f'--append={append}', f'--initrd={mntdir}{initrd}'])
subprocess.Popen (['kexec', '-e'])
elif 'Windows' == type:
# Comprobar tipo de sistema.
if InventoryLib.ogIsEfiActive():
bootlabel = f'Part-{int(disk):02d}-{int(par):02d}'
# Obtener parcición EFI.
esp = DiskLib.ogGetEsp()
efidisk, efipart = esp.split()
if not efipart:
SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_PARTITION, 'ESP')
return None
efidir = FileSystemLib.ogMount (efidisk, efipart)
if not efidir: return None
# Comprobar cargador (si no existe buscar por defecto en ESP).
loader = FileLib.ogGetPath (file=f'{efidir}/EFI/{bootlabel}/Boot/bootmgfw.efi')
if not loader:
bootlabel = 'Microsoft'
loader = FileLib.ogGetPath (file=f'{efidir}/EFI/Microsoft/Boot/bootmgfw.efi')
if not loader:
SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_NOTOS, f'{disk} {par} ({type}, EFI)')
return None
# Crear orden de arranque (con unos valores por defecto).
l = re.sub ('^.*EFI(.*)$', r'\1', loader)
UEFILib.ogNvramAddEntry (bootlabel, l, nvramperm)
# Marcar próximo arranque y reiniciar.
UEFILib.ogNvramSetNext (bootlabel)
subprocess.run (['reboot'])
else:
# Arranque BIOS: comprueba si hay un cargador de Windows.
for f in ['io.sys', 'ntldr', 'bootmgr']:
file = FileLib.ogGetPath (src=f'{disk} {par}', file=f)
if file: loader=f
if not loader:
SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_NOTOS, f'{disk} {par} ({type})')
return None
winboot = os.environ.get ('winboot', '')
if 'kexec' == winboot:
# Modo de arranque en caliente (con kexec).
for f in glob.glob (f'{ogGlobals.OGLIB}/grub4dos/*'):
shutil.copy2 (f, mntdir)
disk0 = int(disk)-1
par0 = int(par)-1
subprocess.run (['kexec', '-l', f'{mntdir}/grub.exe', '--append=--config-file=root (hd{disk0},{par0}); chainloader (hd{disk0},{par0})/{loader}; tpm --init'])
subprocess.Popen (['kexec', '-e'])
else:
# Modo de arranque por reinicio (con reboot).
subprocess.run (['dd', 'if=/dev/zero', f'of={mntdir}/ogboot.me', 'bs=1024', 'count=3'])
subprocess.run (['dd', 'if=/dev/zero', f'of={mntdir}/ogboot.firstboot', 'bs=1024', 'count=3'])
subprocess.run (['dd', 'if=/dev/zero', f'of={mntdir}/ogboot.secondboot', 'bs=1024', 'count=3'])
v = RegistryLib.ogGetRegistryValue (mntdir, 'SOFTWARE', r'\Microsoft\Windows\CurrentVersion\Run\ogcleannboot')
if not v:
RegistryLib.ogAddRegistryValue (mntdir, 'SOFTWARE', r'\Microsoft\Windows\CurrentVersion\Run\ogcleanboot')
RegistryLib.ogSetRegistryValue (mntdir, 'SOFTWARE', r'\Microsoft\Windows\CurrentVersion\Run\ogcleanboot', r'cmd /c del c:\ogboot.*')
# Activar la partición.
DiskLib.ogSetPartitionActive (disk, par)
subprocess.run (['reboot'])
elif 'MacOS' == type:
# Modo de arranque por reinicio.
# Nota: el cliente tiene que tener configurado correctamente Grub.
if not os.path.exists (f'{mntdir}/boot.mac'):
open (f'{mntdir}/boot.mac', 'w').close()
subprocess.run (['reboot'])
elif 'GrubLoader' == type:
# Reiniciar.
#subprocess.run (['reboot'])
pass
else:
SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_NOTOS, f'{disk} {par} ({type})')
return None
#/** #/**
@ -49,6 +213,12 @@ import UEFILib
#@exception OG_ERR_NOTFOUND Disco o particion no corresponden con un dispositivo. #@exception OG_ERR_NOTFOUND Disco o particion no corresponden con un dispositivo.
#@exception OG_ERR_PARTITION Tipo de partición desconocido o no se puede montar. #@exception OG_ERR_PARTITION Tipo de partición desconocido o no se puede montar.
#*/ ## #*/ ##
def ogGetWindowsName (disk, par):
mntdir = FileSystemLib.ogMount (disk, par)
if not mntdir: return None
# Obtener dato del valor de registro.
return RegistryLib.ogGetRegistryValue (mntdir, 'system', r'\ControlSet001\Control\ComputerName\ComputerName\ComputerName')
#/** #/**
@ -62,6 +232,52 @@ import UEFILib
#@exception OG_ERR_PARTITION Tipo de partición desconocido o no se puede montar. #@exception OG_ERR_PARTITION Tipo de partición desconocido o no se puede montar.
#@warning Función básica usada por \c ogBoot #@warning Función básica usada por \c ogBoot
#*/ ## #*/ ##
def ogLinuxBootParameters (disk, par):
# Detectar id. de tipo de partición y codificar al mnemonico.
mntdir = FileSystemLib.ogMount (disk, par)
if not mntdir: return None
# Fichero de configuración de GRUB.
confdir = mntdir # Sistema de archivos de arranque (/boot).
if os.path.isdir (f'{mntdir}/boot'):
confdir = f'{mntdir}/boot' # Sist. archivos raíz con directorio boot.
## original bash code:
## $MNTDIR/{,boot/}{{grubMBR,grubPARTITION}/boot/,}{grub{2,},{,efi/}EFI/*}/{menu.lst,grub.cfg}; do
conffile = None
for _uno in ['', 'boot']:
for _dos in ['grubMBR/boot', 'grubPARTITION/boot', '']:
for _tres in ['grub', 'grub2', 'EFI/*', 'efi/EFI/*']:
for _cuatro in ['menu.lst', 'grub.cfg']:
path = '/'.join ([mntdir, _uno, _dos, _tres, _cuatro])
if os.path.exists (path):
conffile = path
if not conffile:
SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_NOTFOUND, 'grub.cfg')
return None
# Toma del fichero de configuracion los valores del kernel, initrd
# y parámetros de arranque usando las cláusulas por defecto
# ("default" en GRUB1, "set default" en GRUB2)
# y los formatea para que sean compatibles con \c kexec . */
awk_script = '''BEGIN {cont=-1;}
$1~/^default$/ {sub(/=/," "); def=$2;}
$1~/^set$/ && $2~/^default/ { gsub(/[="]/," "); def=$3;
if (def ~ /saved_entry/) def=0;
}
$1~/^(title|menuentry)$/ {cont++}
$1~/^set$/ && $2~/^root=.\\(hd__DISK__,(msdos|gpt)__PAR__\\).$/ { if (def==0) def=cont; }
$1~/^(kernel|linux(16|efi)?)$/ { if (def==cont) {
kern=$2;
sub($1,""); sub($1,""); sub(/^[ \\t]*/,""); app=$0
}
}
$1~/^initrd(16|efi)?$/ {if (def==cont) init=$2}
END {if (kern!="") printf("%s %s %s", kern,init,app)}
'''
awk_script = awk_script.replace ('__DISK__', str (int (disk) - 1))
awk_script = awk_script.replace ('__PAR__', par)
awk_out = subprocess.run (['awk', awk_script, conffile], capture_output=True, text=True).stdout
return awk_out
#/** #/**
@ -105,6 +321,10 @@ def ogSetWindowsName (disk, par, name):
#@exception OG_ERR_NOTFOUND Disco o particion no corresponden con un dispositivo. #@exception OG_ERR_NOTFOUND Disco o particion no corresponden con un dispositivo.
#@exception OG_ERR_PARTITION Tipo de partición desconocido o no se puede montar. #@exception OG_ERR_PARTITION Tipo de partición desconocido o no se puede montar.
#*/ ## #*/ ##
def ogSetWinlogonUser (disk, par, username):
mntdir = FileSystemLib.ogMount (disk, par)
if not mntdir: return None
RegistryLib.ogSetRegistryValue (mntdir, 'SOFTWARE', r'\Microsoft\Windows NT\CurrentVersion\Winlogon\DefaultUserName', username)
#/** #/**
@ -116,6 +336,11 @@ def ogSetWindowsName (disk, par, name):
#@exception OG_ERR_PARTITION Tipo de partición desconocido o no se puede montar. #@exception OG_ERR_PARTITION Tipo de partición desconocido o no se puede montar.
#*/ ## #*/ ##
def ogBootMbrXP (disk):
DISK = DiskLib.ogDiskToDev (disk)
if not DISK: return None
subprocess.run (['ms-sys', '-z', '-f', DISK])
subprocess.run (['ms-sys', '-m', '-f', DISK])
#/** #/**
# ogBootMbrGeneric int_ndisk # ogBootMbrGeneric int_ndisk
@ -126,6 +351,17 @@ def ogSetWindowsName (disk, par, name):
#@exception OG_ERR_NOTFOUND Tipo de partición desconocido o no se puede montar. #@exception OG_ERR_NOTFOUND Tipo de partición desconocido o no se puede montar.
#*/ ## #*/ ##
def ogBootMbrGeneric (disk):
DISK = DiskLib.ogDiskToDev (disk)
if not DISK: return None
subprocess.run (['ms-sys', '-z', '-f', DISK])
subprocess.run (['ms-sys', '-s', '-f', DISK])
# Firma necesaria para Windows equipos UEFI
with open ('/proc/sys/kernel/random/uuid', 'r') as fd:
kernel_random_uuid = fd.read().split ('-')[0]
signature = f'0x{kernel_random_uuid}'
subprocess.run (['ms-sys', '-S', signature, DISK])
@ -169,6 +405,10 @@ fix_first_sector=yes
#@exception OG_ERR_FORMAT Formato incorrecto. #@exception OG_ERR_FORMAT Formato incorrecto.
#@exception OG_ERR_NOTFOUND Dispositivo de disco no encontrado. #@exception OG_ERR_NOTFOUND Dispositivo de disco no encontrado.
#*/ ## #*/ ##
def ogGetBootMbr (disk):
DISK = DiskLib.ogDiskToDev (disk)
if not DISK: return None
subprocess.run (['ms-sys', '-f', DISK])
#/** #/**
# ogWindowsBootParameters int_ndisk int_parition # ogWindowsBootParameters int_ndisk int_parition
@ -414,6 +654,9 @@ def ogGrubInstallMbr (disk, par, checkos='FALSE', kernelparam=''):
if InventoryLib.ogIsEfiActive(): if InventoryLib.ogIsEfiActive():
esp = DiskLib.ogGetEsp() esp = DiskLib.ogGetEsp()
if not esp:
SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_PARTITION, 'ESP')
return None
efidisk, efipart = esp.split() efidisk, efipart = esp.split()
# Comprobamos que exista ESP y el directorio para ubuntu # Comprobamos que exista ESP y el directorio para ubuntu
efisecondstage = FileSystemLib.ogMount (efidisk, efipart) efisecondstage = FileSystemLib.ogMount (efidisk, efipart)
@ -439,7 +682,7 @@ def ogGrubInstallMbr (disk, par, checkos='FALSE', kernelparam=''):
prefixsecondstage = '' # Reactivamos el grub con el grub.cfg original. prefixsecondstage = '' # Reactivamos el grub con el grub.cfg original.
else: # SI Reconfigurar segunda etapa (grub.cfg) == TRUE else: # SI Reconfigurar segunda etapa (grub.cfg) == TRUE
#llamada a updateBootCache para que aloje la primera fase del ogLive #llamada a updateBootCache para que aloje la primera fase del ogLive
subprocess.run ([f'{ogGlobals.OGSCRIPTS}/updateBootCache.py'], check=True) ## TODO: check that this works subprocess.run ([f'{ogGlobals.OGSCRIPTS}/updateBootCache.py'], check=True)
if InventoryLib.ogIsEfiActive(): if InventoryLib.ogIsEfiActive():
# UEFI: grubSintax necesita grub.cfg para detectar los kernels: si no existe recupero backup. # UEFI: grubSintax necesita grub.cfg para detectar los kernels: si no existe recupero backup.
@ -453,7 +696,7 @@ def ogGrubInstallMbr (disk, par, checkos='FALSE', kernelparam=''):
fd.write ('GRUB_DISABLE_RECOVERY="true"\n') fd.write ('GRUB_DISABLE_RECOVERY="true"\n')
fd.write ('GRUB_DISABLE_LINUX_UUID="true"\n') fd.write ('GRUB_DISABLE_LINUX_UUID="true"\n')
os.makedirs (f'{secondstage}{prefixsecondstage}/boot/grub/') #Preparar configuración segunda etapa: crear ubicacion os.makedirs (f'{secondstage}{prefixsecondstage}/boot/grub/', exist_ok=True) #Preparar configuración segunda etapa: crear ubicacion
subprocess.run (['sed', '-i', 's/^set -e/#set -e/', '/etc/grub.d/00_header']) #Preparar configuración segunda etapa: crear cabecera del fichero (ingnorar errores) subprocess.run (['sed', '-i', 's/^set -e/#set -e/', '/etc/grub.d/00_header']) #Preparar configuración segunda etapa: crear cabecera del fichero (ingnorar errores)
# (ogLive 5.0) Si 'pkgdatadir' está vacía ponemos valor de otros ogLive # (ogLive 5.0) Si 'pkgdatadir' está vacía ponemos valor de otros ogLive
subprocess.run (['sed', '-i', r'/grub-mkconfig_lib/i\pkgdatadir=${pkgdatadir:-"${datarootdir}/grub"}', '/etc/grub.d/00_header']) subprocess.run (['sed', '-i', r'/grub-mkconfig_lib/i\pkgdatadir=${pkgdatadir:-"${datarootdir}/grub"}', '/etc/grub.d/00_header'])
@ -575,11 +818,14 @@ def ogGrubInstallPartition (disk, par, checkos='FALSE', kernelparam=''):
with open (f'{secondstage}{prefixsecondstage}/boot/grub/grub.cfg', 'a') as fd: with open (f'{secondstage}{prefixsecondstage}/boot/grub/grub.cfg', 'a') as fd:
fd.write (out + '\n') fd.write (out + '\n')
#Instalar el grub
eval = subprocess.run (['grub-install', '--force'] + efioptgrub + [f'--root-directory={secondstage}{prefixsecondstage}', firststage]).returncode eval = subprocess.run (['grub-install', '--force'] + efioptgrub + [f'--root-directory={secondstage}{prefixsecondstage}', firststage]).returncode
if InventoryLib.ogIsEfiActive(): # Movemos el grubx64.efi # Movemos el grubx64.efi
if InventoryLib.ogIsEfiActive():
for b in (glob.glob (f'{efisecondstage}/EFI/{efisubdir}/EFI/BOOT/*')): for b in (glob.glob (f'{efisecondstage}/EFI/{efisubdir}/EFI/BOOT/*')):
os.rename (f'{efisecondstage}/EFI/{efisubdir}/EFI/BOOT/{b}', f'{efisecondstage}/EFI/{efisubdir}/Boot/{b}') bn = os.path.basename (b)
os.rename (f'{efisecondstage}/EFI/{efisubdir}/EFI/BOOT/{bn}', f'{efisecondstage}/EFI/{efisubdir}/Boot/{bn}')
shutil.rmtree (f'{efisecondstage}/EFI/{efisubdir}/EFI') shutil.rmtree (f'{efisecondstage}/EFI/{efisubdir}/EFI')
shutil.copy2 ('/usr/lib/shim/shimx64.efi.signed', f'{efisecondstage}/EFI/{efisubdir}/Boot/shimx64.efi') shutil.copy2 ('/usr/lib/shim/shimx64.efi.signed', f'{efisecondstage}/EFI/{efisubdir}/Boot/shimx64.efi')
# Nombre OpenGnsys para cargador # Nombre OpenGnsys para cargador
@ -668,6 +914,30 @@ def ogConfigureFstab (disk, par):
#@exception OG_ERR_PARTITION Tipo de partición desconocido o no se puede montar. #@exception OG_ERR_PARTITION Tipo de partición desconocido o no se puede montar.
#@note Si no se indica nombre, se asigna un valor por defecto. #@note Si no se indica nombre, se asigna un valor por defecto.
#*/ ## #*/ ##
def ogSetLinuxName (disk, par, hostname='pc'):
# Montar el sistema de archivos.
mntdir = FileSystemLib.ogMount (disk, par)
if not mntdir: return None
etc = FileLib.ogGetPath (src=f'{disk} {par}', file='/etc')
if os.path.isdir (etc):
#cambio de nombre en hostname
with open (f'{etc}/hostname', 'w') as fd:
fd.write (f'{hostname}\n')
#Opcion A para cambio de nombre en hosts
#sed "/127.0.1.1/ c\127.0.1.1 \t $HOSTNAME" $ETC/hosts > /tmp/hosts && cp /tmp/hosts $ETC/ && rm /tmp/hosts
#Opcion B componer fichero de hosts
with open (f'{etc}/hosts', 'w') as fd:
fd.write ('127.0.0.1 localhost\n')
fd.write (f'127.0.1.1 {hostname}\n')
fd.write ('\n')
fd.write ('# The following lines are desirable for IPv6 capable hosts\n')
fd.write ('::1 ip6-localhost ip6-loopback\n')
fd.write ('fe00::0 ip6-localnet\n')
fd.write ('ff00::0 ip6-mcastprefix\n')
fd.write ('ff02::1 ip6-allnodes\n')
fd.write ('ff02::2 ip6-allrouters\n')
@ -707,17 +977,89 @@ def ogCleanLinuxDevices (disk, par):
# /// FIXME: Solo para el grub instalado en MBR por Opengnsys, ampliar para más casos. # /// FIXME: Solo para el grub instalado en MBR por Opengnsys, ampliar para más casos.
#*/ ## #*/ ##
def ogGrubAddOgLive (disk, par, timeout=None, offline=''):
oglivedir = os.environ.get ('oglivedir', 'ogLive')
# Error si no existe el kernel y el initrd en la cache.
# Falta crear nuevo codigo de error.
if not os.path.exists (f'{ogGlobals.OGCAC}/boot/{oglivedir}/ogvmlinuz') or not os.path.exists (f'{ogGlobals.OGCAC}/boot/{oglivedir}/oginitrd.img'):
SystemLib.ogRaiseError (['log', 'session'], ogGlobals.OG_ERR_NOTFOUND, 'CACHE: ogvmlinuz, oginitrd.img')
return None
# Archivo de configuracion del grub
dirmount = FileSystemLib.ogMount (disk, par)
grubcfg = f'{dirmount}/boot/grubMBR/boot/grub/grub.cfg'
# Error si no existe archivo del grub
if not os.path.exists (grubcfg):
SystemLib.ogRaiseError (['log', 'session'], ogGlobals.OG_ERR_NOTFOUND, grubcfg)
return None
# Si existe la entrada de opengnsys, se borra
grubcfg_contents = ''
with open (grubcfg, 'r') as fd:
grubcfg_contents = fd.read()
if 'menuentry Opengnsys' in grubcfg_contents:
subprocess.run (['sed', '-ie', '/menuentry Opengnsys/,+6d', grubcfg])
# Tipo de tabla de particiones
parttabletype = DiskLib.ogGetPartitionTableType (disk)
parttabletype = parttabletype.lower()
# Localizacion de la cache
cachepart = CacheLib.ogFindCache()
if not cachepart:
SystemLib.ogRaiseError (['log', 'session'], ogGlobals.OG_ERR_NOTCACHE, '')
return None
numdisk, numpart = cachepart.split()
numdisk = int (numdisk) - 1
# kernel y sus opciones. Pasamos a modo usuario
proc_cmdline = ''
with open ('/proc/cmdline', 'r') as fd:
proc_cmdline = fd.read().strip()
proc_cmdline = re.sub ('^.*linuz', '', proc_cmdline)
proc_cmdline = re.sub ('ogactiveadmin=[a-z]*', '', proc_cmdline)
kernel = f'/boot/{oglivedir}/ogvmlinuz {proc_cmdline}'
# Configuracion offline si existe parametro
STATUS = ''
if not offline: offline = ''
if 'offline' in offline: STATUS = 'offline'
if 'online' in offline: STATUS = 'online'
if STATUS:
kernel = re.sub ('ogprotocol=[a-z]* ', 'ogprotocol=local ', kernel)
kernel += f' ogstatus={STATUS}'
# Numero de línea de la primera entrada del grub.
grep_out = subprocess.run (['grep', '--line-number', '--max-count', '1', '^menuentry', grubcfg], capture_output=True, text=True).stdout
numline, _ = grep_out.split (':', maxsplit=1)
# Texto de la entrada de opengnsys
menuentry = f'''menuentry "OpenGnsys" --class opengnsys --class gnu --class os {{ \\
\tinsmod part_{parttabletype} \\
\tinsmod ext2 \\
\tset root='(hd{numdisk},{parttabletype}{numpart})' \\
\tlinux {kernel} \\
\tinitrd /boot/{oglivedir}/oginitrd.img \\
}}'''
# Insertamos la entrada de opengnsys antes de la primera entrada existente.
subprocess.run (['sed', '-i', f'{numline}i\\ {menuentry}', grubcfg])
# Ponemos que la entrada por defecto sea la primera.
subprocess.run (['sed', '-i', f's/set.*default.*$/set default="0"/g', grubcfg])
# Si me dan valor para timeout lo cambio en el grub.
if timeout:
subprocess.run (['sed', '-i', f's/timeout=.*$/timeout={timeout}/g', grubcfg])
#/** #/**
# ogGrubHidePartitions num_disk num_part # ogGrubHidePartitions num_disk num_part
#@brief ver ogBootLoaderHidePartitions #@brief ver ogBootLoaderHidePartitions
#@see ogBootLoaderHidePartitions #@see ogBootLoaderHidePartitions
#*/ ## #*/ ##
def ogGrubHidePartitions (disk, par, datadisk=None, datapar=None):
#/** return ogBootLoaderHidePartitions (disk, par, datadisk, datapar)
# ogBurgHidePartitions num_disk num_part
#@brief ver ogBootLoaderHidePartitions
#@see ogBootLoaderHidePartitions
#*/ ##
#/** #/**
# ogBootLoaderHidePartitions num_disk num_part # ogBootLoaderHidePartitions num_disk num_part
@ -731,23 +1073,89 @@ def ogCleanLinuxDevices (disk, par):
#@exception No existe archivo de configuracion del grub/burg. #@exception No existe archivo de configuracion del grub/burg.
#*/ #*/
def ogBootLoaderHidePartitions (disk, par, datadisk=None, datapar=None):
# Nombre de la función que llama a esta.
func = inspect.stack()[1][3]
# Si no existe $4 pongo un valor imposible para la partición de datos
if datapar:
partdata = DiskLib.ogDiskToDev (datadisk, datapar)
else:
partdata = '0'
# Archivo de configuracion del grub
DIRMOUNT = FileSystemLib.ogMount (disk, par)
# La función debe ser llamanda desde ogGrubHidePartitions or ogBurgHidePartitions.
if 'ogGrubHidePartitions' == func:
cfgfile = f'{DIRMOUNT}/boot/grubMBR/boot/grub/grub.cfg'
else:
SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_FORMAT, f'Use ogGrubHidePartitions')
return None
# Error si no existe archivo del grub
if not os.path.exists (cfgfile):
SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_NOTFOUND, cfgfile)
return None
# Si solo hay una particion de Windows me salgo
num_ntfs = 0
disks = DiskLib.ogDiskToDev()
fdisk_out = subprocess.run (['fdisk', '-l']+disks, capture_output=True, text=True).stdout
for l in fdisk_out.splitlines():
if 'NTFS' in l: num_ntfs += 1
if 1 == num_ntfs: return True
# Elimino llamadas a parttool, se han incluido en otras ejecuciones de esta funcion.
subprocess.run (['sed', '-i', '/parttool/d', cfgfile])
parttabletype = DiskLib.ogGetPartitionTableType (disk)
parttabletype = parttabletype.lower()
# Entradas de Windows: numero de linea y particion. De mayor a menor.
#1:/dev/sda2
#2:/dev/sda3
awk_out = subprocess.run (f'''
awk '/menuentry.*Windows/ {{gsub(/\\)"/, ""); gsub(/^.*dev/,""); print NR":/dev"$1}} ' {cfgfile}
''', shell=True, text=True, capture_output=True).stdout
if awk_out:
winentry = awk_out.splitlines()
winentry.reverse()
else:
winentry = []
# Particiones de Windows, pueden no estar en el grub.
winpart = []
for l in fdisk_out.splitlines(): ## aprovechamos la variable fdisk_out de antes
if 'NTFS' not in l: continue
items = l.split (' ')
winpart.append (items[0])
winpart.reverse()
# Modifico todas las entradas de Windows.
for entry in winentry:
line, part = entry.split (':')
# En cada entrada, oculto o muestro cada particion.
text = ''
for parthidden in winpart:
# Muestro la particion de la entrada actual y la de datos.
if parthidden == part or parthidden == partdata:
hidden = '-'
else:
hidden = '+'
numdisk, numpart = DiskLib.ogDevToDisk (parthidden).split()
numdisk = int (numdisk)
numpart = int (numpart)
text = f'\tparttool (hd{numdisk-1},{parttabletype}{numpart}) hidden{hidden} \n{text}'
subprocess.run (['sed', '-i', f'{line}a\\ {text}', cfgfile])
# Activamos la particion que se inicia en todas las entradas de windows.
subprocess.run (['sed', '-i', '/chainloader/i\\\tparttool ${root} boot+', cfgfile])
#/** #/**
# ogGrubDeleteEntry num_disk num_part num_disk_delete num_part_delete # ogGrubDeleteEntry num_disk num_part num_disk_delete num_part_delete
#@brief ver ogBootLoaderDeleteEntry #@brief ver ogBootLoaderDeleteEntry
#@see ogBootLoaderDeleteEntry #@see ogBootLoaderDeleteEntry
#*/ #*/
def ogGrubDeleteEntry (disk, par, diskdel, pardel):
#/** return ogBootLoaderDeleteEntry (disk, par, diskdel, pardel)
# ogBurgDeleteEntry num_disk num_part num_disk_delete num_part_delete
#@brief ver ogBootLoaderDeleteEntry
#@see ogBootLoaderDeleteEntry
#*/
#/**
# ogRefindDeleteEntry num_disk_delete num_part_delete
#@brief ver ogBootLoaderDeleteEntry
#@see ogBootLoaderDeleteEntry
#*/
#/** #/**
# ogBootLoaderDeleteEntry num_disk num_part num_part_delete # ogBootLoaderDeleteEntry num_disk num_part num_part_delete
@ -756,43 +1164,73 @@ def ogCleanLinuxDevices (disk, par):
#@param 2 Numero de particion donde esta el grub #@param 2 Numero de particion donde esta el grub
#@param 3 Numero del disco del que borramos las entradas #@param 3 Numero del disco del que borramos las entradas
#@param 4 Numero de la particion de la que borramos las entradas #@param 4 Numero de la particion de la que borramos las entradas
#@note Tiene que ser llamada desde ogGrubDeleteEntry, ogBurgDeleteEntry o ogRefindDeleteEntry #@note Tiene que ser llamada desde ogGrubDeleteEntry
#@return (nada) #@return (nada)
#@exception OG_ERR_FORMAT Use ogGrubDeleteEntry or ogBurgDeleteEntry. #@exception OG_ERR_FORMAT Use ogGrubDeleteEntry
#@exception OG_ERR_FORMAT Formato incorrecto. #@exception OG_ERR_FORMAT Formato incorrecto.
#@exception OG_ERR_NOTFOUND No existe archivo de configuracion del grub. #@exception OG_ERR_NOTFOUND No existe archivo de configuracion del grub.
#*/ ## #*/ ##
#/** def ogBootLoaderDeleteEntry (disk, par, diskdel, pardel):
# ogBurgInstallMbr int_disk_GRUBCFG int_partition_GRUBCFG # Nombre de la función que llama a esta.
#@param bolean_Check_Os_installed_and_Configure_2ndStage true | false[default] func = inspect.stack()[1][3]
#@brief Instala y actualiza el gestor grub en el MBR del disco duro donde se encuentra el fichero grub.cfg. Admite sistemas Windows.
#@param int_disk_SecondStage
#@param int_part_SecondStage
#@param bolean_Check_Os_installed_and_Configure_2ndStage true | false[default]
#@return
#@exception OG_ERR_FORMAT Formato incorrecto.
#@exception OG_ERR_PARTITION Partición no soportada
#*/ ##
# Archivo de configuracion del grub
dirmount = FileSystemLib.ogMount (disk, par)
# La función debe ser llamanda desde ogGrubDeleteEntry, ogBurgDeleteEntry or ogRefindDeleteEntry.
if 'ogGrubDeleteEntry' == func:
cfgfile = f'{dirmount}/boot/grubMBR/boot/grub/grub.cfg'
else:
SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_FORMAT, f'Use ogGrubDeleteEntry')
return None
# Dispositivo
label = DiskLib.ogDiskToDev (diskdel, pardel)
# Error si no existe archivo de configuración
if not os.path.exists (cfgfile):
SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_NOTFOUND, cfgfile)
return None
# Numero de linea de cada entrada.
menuentry = []
grep_out = subprocess.run (['grep', '-n', '-e', 'menuentry', cfgfile], capture_output=True, text=True).stdout
if grep_out:
for l in grep_out.splitlines():
lineno, _ = l.split (':', maxsplit=1)
menuentry.append (lineno)
menuentry.reverse()
# Entradas que hay que borrar.
deleteentry = []
grep_out = subprocess.run (['grep', '-n', f'menuentry.*{label}', cfgfile], capture_output=True, text=True).stdout
if grep_out:
for l in grep_out.splitlines():
lineno, _ = l.split (':', maxsplit=1)
deleteentry.append (lineno)
# Si no hay entradas para borrar me salgo con aviso
if not deleteentry:
SystemLib.ogRaiseError (['log', 'session'], ogGlobals.OG_ERR_NOTFOUND, f'Menuentry {label}')
return None
# Recorremos el fichero del final hacia el principio.
with open (cfgfile, 'r') as fd:
endentry = len (fd.read().splitlines())
for entry in menuentry:
# Comprobamos si hay que borrar la entrada.
if entry in deleteentry:
endentry -= 1
subprocess.run (['sed', '-i', '-e', f'{entry},{endentry}d', cfgfile])
# Guardamos el número de línea de la entrada, que sera el final de la siguiente.
endentry = entry
#/** #/**
# ogGrubDefaultEntry int_disk_GRUGCFG int_partition_GRUBCFG int_disk_default_entry int_npartition_default_entry # ogGrubDefaultEntry int_disk_GRUGCFG int_partition_GRUBCFG int_disk_default_entry int_npartition_default_entry
#@brief ver ogBootLoaderDefaultEntry #@brief ver ogBootLoaderDefaultEntry
#@see ogBootLoaderDefaultEntry #@see ogBootLoaderDefaultEntry
#*/ ## #*/ ##
def ogGrubDefaultEntry (disk, par, diskdefault, pardefault):
#/** return ogBootLoaderDefaultEntry (disk, par, diskdefault, pardefault)
# ogBurgDefaultEntry int_disk_BURGCFG int_partition_BURGCFG int_disk_default_entry int_npartition_default_entry
#@brief ver ogBootLoaderDefaultEntry
#@see ogBootLoaderDefaultEntry
#*/ ##
#/**
# ogRefindDefaultEntry int_disk_default_entry int_npartition_default_entry
#@brief ver ogBootLoaderDefaultEntry
#@see ogBootLoaderDefaultEntry
#*/ ##
#/** #/**
# ogBootLoaderDefaultEntry int_disk_CFG int_partition_CFG int_disk_default_entry int_npartition_default_entry # ogBootLoaderDefaultEntry int_disk_CFG int_partition_CFG int_disk_default_entry int_npartition_default_entry
@ -807,25 +1245,64 @@ def ogCleanLinuxDevices (disk, par):
#@exception OG_ERR_OUTOFLIMIT Param $3 no es entero. #@exception OG_ERR_OUTOFLIMIT Param $3 no es entero.
#@exception OG_ERR_NOTFOUND Fichero de configuración no encontrado: burg.cfg. #@exception OG_ERR_NOTFOUND Fichero de configuración no encontrado: burg.cfg.
#*/ ## #*/ ##
def ogBootLoaderDefaultEntry (disk, par, diskdefault, pardefault):
# Nombre de la función que llama a esta.
func = inspect.stack()[1][3]
# Error si no puede montar sistema de archivos.
dirmount = FileSystemLib.ogMount (disk, par)
if not dirmount: return None
# Comprobamos que exista fichero de configuración
# La función debe ser llamanda desde ogGrubDefaultEntry, ogBurgDefaultEntry or ogRefindDefaultEntry.
if 'ogGrubDefaultEntry' == func:
cfgfile = f'{dirmount}/boot/grubMBR/boot/grub/grub.cfg'
else:
SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_FORMAT, f'Use ogGrubDefaultEntry')
return None
# Error si no existe archivo de configuración
if not os.path.exists (cfgfile):
SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_NOTFOUND, cfgfile)
return None
# Dispositivo
label = DiskLib.ogDiskToDev (diskdefault, pardefault)
# Número de línea de la entrada por defecto en CFGFILE (primera de la partición).
grep_out = subprocess.run (['grep', '--line-number', '--max-count', '1', f'menuentry.*{label}', cfgfile], capture_output=True, text=True).stdout
if not grep_out:
SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_NOTFOUND, f'menuentry {label}')
return None
defaultentry, _ = grep_out.split (':', maxsplit=1)
# Si no hay entradas para borrar me salgo con aviso
if not defaultentry:
SystemLib.ogRaiseError (['session', 'log'], ogGlobals.OG_ERR_NOTFOUND, f'No menuentry {label}')
return None
# Número de la de linea por defecto en el menú de usuario
menuentry = subprocess.run (f'grep -n -e menuentry {cfgfile}| cut -d: -f1 | grep -n {defaultentry} |cut -d: -f1', shell=True, text=True, capture_output=True).stdout
if not menuentry: return None
menuentry = int (menuentry)
# En grub y burg las líneas empiezan a contar desde cero
menuentry -= 1
subprocess.run (['sed', '--regexp-extended', '-i', f's/set default="?[0-9]*"?$/set default="{menuentry}"/g', cfgfile])
MSG = f'ogGlobals.lang.MSG_HELP_{func}'
try: MSG = eval (MSG)
except: MSG = ''
if '.' == MSG[-1]: MSG=MSG[0:-1]
print (f'{MSG}: {disk} {par} {diskdefault} {pardefault}')
return True
#/** #/**
# ogGrubOgliveDefaultEntry num_disk num_part # ogGrubOgliveDefaultEntry num_disk num_part
#@brief ver ogBootLoaderOgliveDefaultEntry #@brief ver ogBootLoaderOgliveDefaultEntry
#@see ogBootLoaderOgliveDefaultEntry #@see ogBootLoaderOgliveDefaultEntry
#*/ ## #*/ ##
def ogGrubOgliveDefaultEntry (disk, par):
#/** return ogBootLoaderOgliveDefaultEntry (disk, par)
# ogBurgOgliveDefaultEntry num_disk num_part
#@brief ver ogBootLoaderOgliveDefaultEntry
#@see ogBootLoaderOgliveDefaultEntry
#*/ ##
#/**
# ogRefindOgliveDefaultEntry
#@brief ver ogBootLoaderOgliveDefaultEntry
#@see ogBootLoaderOgliveDefaultEntry
#*/ ##
#/** #/**
@ -839,6 +1316,49 @@ def ogCleanLinuxDevices (disk, par):
#@exception OG_ERR_NOTFOUND Fichero de configuración no encontrado: burg.cfg. #@exception OG_ERR_NOTFOUND Fichero de configuración no encontrado: burg.cfg.
#@exception OG_ERR_NOTFOUND Entrada de OgLive no encontrada en burg.cfg. #@exception OG_ERR_NOTFOUND Entrada de OgLive no encontrada en burg.cfg.
#*/ ## #*/ ##
def ogBootLoaderOgliveDefaultEntry (disk, par):
# Nombre de la función que llama a esta.
func = inspect.stack()[1][3]
# Error si no puede montar sistema de archivos.
PART = FileSystemLib.ogMount (disk, par)
if not PART: return None
# La función debe ser llamanda desde ogGrubOgliveDefaultEntry, ogBurgOgliveDefaultEntry or ogRefindOgliveDefaultEntry.
if 'ogGrubOgliveDefaultEntry' == func:
cfgfile = f'{PART}/boot/grubMBR/boot/grub/grub.cfg'
else:
SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_FORMAT, f'Use ogGrubOgliveDefaultEntry')
return None
# Comprobamos que exista fichero de configuración
if not os.path.exists (cfgfile):
SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_NOTFOUND, cfgfile)
return None
# Detectamos cual es la entrada de ogLive
numentry = 0
with open (cfgfile, 'r') as fd:
while True:
l = fd.readline()
if not l: break
if l.startswith ('menuentry'):
numentry += 1
if 'OpenGnsys Live' in l: break
# Si no existe entrada de ogLive nos salimos
if not numentry:
SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_NOTFOUND, f'menuentry OpenGnsys Live in {cfgfile}')
return None
numentry -= 1
subprocess.run (['sed', '--regexp-extended', '-i', f's/set default="?[0-9]+"?/set default="{numentry}"/g', cfgfile])
MSG = f'ogGlobals.lang.MSG_HELP_{func}'
try: MSG = eval (MSG)
except: MSG = ''
if '.' == MSG[-1]: MSG=MSG[0:-1]
print (f'{MSG}: {disk} {par}')
return True
#/** #/**
@ -853,6 +1373,45 @@ def ogCleanLinuxDevices (disk, par):
#@exception OG_ERR_PARTITION Tipo de partición desconocido o no se puede montar (ogMount). #@exception OG_ERR_PARTITION Tipo de partición desconocido o no se puede montar (ogMount).
#@exception OG_ERR_NOTFOUND No encuentra archivo de configuración del grub. #@exception OG_ERR_NOTFOUND No encuentra archivo de configuración del grub.
#*/ ## #*/ ##
def ogGrubSecurity (disk, par, user='root', passwd=''):
#localizar disco segunda etapa del grub
secondstage = FileSystemLib.ogMount (disk, par)
if not secondstage: return None
## original bash code:
## $SECONDSTAGE/{,boot/}{{grubMBR,grubPARTITION}/boot/,}{grub{,2},{,efi/}EFI/*}/{menu.lst,grub.cfg,grub.cfg.backup.og}
grubcfg = []
for _uno in ['', 'boot']:
for _dos in ['grubMBR/boot', 'grubPARTITION/boot', '']:
for _tres in ['grub', 'grub2', 'EFI/*', 'efi/EFI/*']:
for _cuatro in ['menu.lst', 'grub.cfg', 'grub.cfg.backup.og']:
path = '/'.join ([secondstage, _uno, _dos, _tres, _cuatro])
grubcfg += glob.glob (path)
print (f'nati grubcfg ({grubcfg})')
# comprobamos que exista el archivo de configuración.
if not grubcfg:
SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_NOTFOUND, 'grub.cfg')
return None
if passwd:
encryptpasswd = subprocess.run (['grub-mkpasswd-pbkdf2'], input=f'{passwd}\n{passwd}', text=True, capture_output=True).stdout
if encryptpasswd:
lines = encryptpasswd.strip().splitlines()
encryptpasswd = lines[-1]
encryptpasswd = re.sub ('^.*grub', 'grub', encryptpasswd)
for file in grubcfg:
# Eliminamos configuración anterior
subprocess.run (['sed', '-i', '-e', '/superusers/d', '-e', '/password_pbkdf2/d', file])
# Configuramos grub.cfg para que sólo permita editar o entrar en línea de comandos al usuario especificado
if passwd:
subprocess.run (['sed', '-i', f'1i\\password_pbkdf2 {user} {encryptpasswd}', file])
subprocess.run (['sed', '-i', f'1i\\set superusers="{user}"', file])
# Permitimos que se seleccionen las entradas
subprocess.run (['sed', '-i', '/menuentry /s/{/--unrestricted {/', file])
#/** #/**
@ -861,19 +1420,6 @@ def ogCleanLinuxDevices (disk, par):
#@see ogBootLoaderSetTheme #@see ogBootLoaderSetTheme
#*/ ## #*/ ##
#/**
# ogBurgSetTheme num_disk num_part str_theme
#@brief ver ogBootLoaderSetTheme
#@see ogBootLoaderSetTheme
#*/ ##
#/**
# ogRefindSetTheme str_theme
#@brief ver ogBootLoaderSetTheme
#@see ogBootLoaderSetTheme
#*/ ##
#/** #/**
# ogBootLoaderSetTheme # ogBootLoaderSetTheme
@ -896,12 +1442,6 @@ def ogCleanLinuxDevices (disk, par):
#@see ogBootLoaderSetTheme #@see ogBootLoaderSetTheme
#*/ ## #*/ ##
#/**
# ogBurgSetAdminKeys num_disk num_part str_bolean
#@brief ver ogBootLoaderSetAdminKeys
#@see ogBootLoaderSetAdminKeys
#*/ ##
#/** #/**
@ -924,19 +1464,8 @@ def ogCleanLinuxDevices (disk, par):
#@brief ver ogBootLoaderSetTimeOut #@brief ver ogBootLoaderSetTimeOut
#@see ogBootLoaderSetTimeOut #@see ogBootLoaderSetTimeOut
#*/ ## #*/ ##
def ogGrubSetTimeOut (disk, par, timeout):
#/** return ogBootLoaderSetTimeOut (disk, par, timeout)
# ogBurgSetTimeOut num_disk num_part str_bolean
#@brief ver ogBootLoaderSetTimeOut
#@see ogBootLoaderSetTimeOut
#*/ ##
#/**
# ogRefindSetTimeOut int_timeout_second
#@brief ver ogBootLoaderSetTimeOut
#@see ogBootLoaderSetTimeOut
#*/ ##
#/** #/**
# ogBootLoaderSetTimeOut # ogBootLoaderSetTimeOut
@ -950,6 +1479,29 @@ def ogCleanLinuxDevices (disk, par):
#@exception OG_ERR_NOTFOUND Fichero de configuración no encontrado: grub.cfg burg.cfg. #@exception OG_ERR_NOTFOUND Fichero de configuración no encontrado: grub.cfg burg.cfg.
#@exception OG_ERR_NOTFOUND Entrada deltema no encontrada en burg.cfg. #@exception OG_ERR_NOTFOUND Entrada deltema no encontrada en burg.cfg.
#*/ ## #*/ ##
def ogBootLoaderSetTimeOut (disk, par, timeout):
# Nombre de la función que llama a esta.
func = inspect.stack()[1][3]
# Error si no puede montar sistema de archivos.
PART = FileSystemLib.ogMount (disk, par)
if not PART: return None
# La función debe ser llamanda desde ogGrubSetTimeOut, ogBurgSetTimeOut or ogRefindSetTimeOut.
if 'ogGrubSetTimeOut' == func:
bootloader = 'grub'
bootloaderdir = 'boot/grubMBR'
cfgfile = f'{PART}/boot/grubMBR/boot/grub/grub.cfg'
else:
SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_FORMAT, f'Use ogGrubSetTimeOut')
return None
# Comprobamos que exista fichero de configuración
if not os.path.exists (cfgfile):
SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_NOTFOUND, cfgfile)
return None
# Asignamos el timeOut.
subprocess.run (['sed', '-i', f's/timeout=.*$/timeout={timeout}/g', cfgfile])
#/** #/**
@ -958,12 +1510,6 @@ def ogCleanLinuxDevices (disk, par):
#@see ogBootLoaderSetResolution #@see ogBootLoaderSetResolution
#*/ ## #*/ ##
#/**
# ogBurgSetResolution num_disk num_part str_bolean
#@brief ver ogBootLoaderSetResolution
#@see ogBootLoaderSetResolution
#*/ ##
#/** #/**
@ -992,18 +1538,6 @@ def ogCleanLinuxDevices (disk, par):
#@exception OG_ERR_NOTFOUND Fichero de configuración no encontrado: grub.cfg burg.cfg. #@exception OG_ERR_NOTFOUND Fichero de configuración no encontrado: grub.cfg burg.cfg.
#*/ ## #*/ ##
# ogRefindInstall bool_autoconfig
#@brief Instala y actualiza el gestor rEFInd en la particion EFI
#@param bolean_Check__auto_config true | false[default]
#@return
#@exception OG_ERR_FORMAT Formato incorrecto.
#@exception OG_ERR_NOTFOUND No se encuentra la partición ESP.
#@exception OG_ERR_NOTFOUND No se encuentra shimx64.efi.signed.
#@exception OG_ERR_NOTFOUND No se encuentra refind-install o refind en OGLIB
#@exception OG_ERR_PARTITION No se puede montar la partición ESP.
#@note Refind debe estar instalado en el ogLive o compartido en OGLIB
#*/ ##
#/** #/**
# ogGrub4dosInstallMbr int_ndisk # ogGrub4dosInstallMbr int_ndisk
#@brief Genera un nuevo Codigo de arranque en el MBR del disco indicado, compatible con los SO tipo Windows, Linux. #@brief Genera un nuevo Codigo de arranque en el MBR del disco indicado, compatible con los SO tipo Windows, Linux.
@ -1016,3 +1550,54 @@ def ogCleanLinuxDevices (disk, par):
#@exception OG_ERR_NOMSDOS Disco duro no particioniado en modo msdos #@exception OG_ERR_NOMSDOS Disco duro no particioniado en modo msdos
#@exception OG_ERR_NOTWRITE Particion no modificable. #@exception OG_ERR_NOTWRITE Particion no modificable.
#*/ ## #*/ ##
def ogGrub4dosInstallMbr (disk, par):
#Controlar existencia de disco y particion
device = DiskLib.ogDiskToDev (disk)
if not device:
SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_NOTFOUND, '')
return None
mountdisk = FileSystemLib.ogMount (disk, par)
if not mountdisk:
SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_PARTITION, ogGlobals.lang.MSG_ERROR)
return None
#Controlar acceso de escritura a la particion
if FileSystemLib.ogIsReadonly (disk, par):
SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_NOTWRITE, f': {disk} {par}')
return None
#Controlar disco no uefi
if InventoryLib.ogIsEfiActive():
SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_NOTBIOS, ' : grub4dos solo soporta PC con bios legacy')
return None
#Controlar particionado tipo msdos
ptt = DiskLib.ogGetPartitionTableType (disk)
if 'MSDOS' != ptt:
SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_NOMSDOS, ': grub2dos requiere particionado tipo MSDOS')
return None
#Controlar la existencia del grub4dos con acceso a ntfs
bindir = f'{ogGlobals.OGLIB}/grub4dos/grub4dos-0.4.6a'
if not os.path.exists (f'{bindir}/bootlace.com'):
SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_NOTFOUND, f': {bindir}/bootlace.com')
return None
#instalar el bootloader de grlrd en el MBR
subprocess.run ([f'{bindir}/bootlace64.com', device], capture_output=True)
#copiar grld a la particion
shutil.copy2 (f'{bindir}/grldr', mountdisk)
#Instalar y configurar grub4dos
if os.path.exists (f'{mountdisk}/boot/grub/menu.lst'):
os.unlink (f'{mountdisk}/boot/grub/menu.lst')
os.rmdir (f'/{mountdisk}/boot/grub')
if not os.path.exists (f'{mountdisk}/boot/grub/menu.lst'):
os.makedirs (f'/{mountdisk}/boot/grub', exist_ok=True)
open (f'/{mountdisk}/boot/grub/menu.lst', 'w').close()
grubdisk = int (disk) - 1
with open (f'/{mountdisk}/boot/grub/menu.lst', 'w') as fd:
fd.write ('##NO-TOCAR-ESTA-LINEA MBR\n')
fd.write ('timeout 0\n')
fd.write ('title MBR\n')
fd.write (f'root (hd{grubdisk},0)\n')
fd.write (f'chainloader (hd{grubdisk},0)+1\n')
fd.write ('boot\n')
fd.write ('EOT\n')
fd.write ('\n')

6
ogclient/lib/python3/CacheLib.py
View File

@ -9,7 +9,6 @@ import ogGlobals
import SystemLib import SystemLib
import DiskLib import DiskLib
import FileSystemLib import FileSystemLib
import CacheLib
#/** #/**
# ogCreateCache [int_ndisk] int_partsize # ogCreateCache [int_ndisk] int_partsize
@ -240,8 +239,7 @@ def ogFormatCache():
os.makedirs (j, exist_ok=True) os.makedirs (j, exist_ok=True)
# Incluir kernel e Initrd del ogLive # Incluir kernel e Initrd del ogLive
## como lo llamo sin especificar el path entero? subprocess.run ([f'{ogGlobals.OGSCRIPTS}/updateBootCache.py'])
#subprocess.run (['scripts/updateBootCache.py']) ## TODO
#/** #/**
@ -365,5 +363,5 @@ def ogUnmountCache():
#@return lo mismo que devuelve initCache #@return lo mismo que devuelve initCache
#*/ ## #*/ ##
def initCache (*args): def initCache (*args):
p = subprocess.run (['/opt/opengnsys/images/nati/client/shared/scripts/initCache.py'] + list(args)) p = subprocess.run ([f'{ogGlobals.OGSCRIPTS}/initCache.py'] + list(args))
return p.returncode return p.returncode

5
ogclient/lib/python3/FileSystemLib.py
View File

@ -14,7 +14,6 @@ import ogGlobals
import SystemLib import SystemLib
import DiskLib import DiskLib
import CacheLib import CacheLib
import FileSystemLib
#/** #/**
@ -295,7 +294,7 @@ def ogGetFsSize (disk, par, unit='KB'):
return return
# Obtener el tamaño del sistema de archivo (si no está formateado; tamaño = 0). # Obtener el tamaño del sistema de archivo (si no está formateado; tamaño = 0).
mnt = FileSystemLib.ogMount (disk, par) mnt = ogMount (disk, par)
if mnt: if mnt:
result = subprocess.run(["df", "-BK", mnt], capture_output=True, text=True) result = subprocess.run(["df", "-BK", mnt], capture_output=True, text=True)
val = result.stdout.split("\n")[1].split()[1] val = result.stdout.split("\n")[1].split()[1]
@ -895,7 +894,7 @@ def ogGetFreeSize(disk, part, unit='KB'):
kk kk
factor = unit2factor[unit.lower()] factor = unit2factor[unit.lower()]
particion = FileSystemLib.ogMount (disk, part) particion = ogMount (disk, part)
if not particion: if not particion:
kk kk
df = subprocess.run (['df'], capture_output=True, text=True).stdout df = subprocess.run (['df'], capture_output=True, text=True).stdout

2
ogclient/lib/python3/ImageLib.py
View File

@ -233,7 +233,7 @@ def ogCreateImage (disk, par, container, imgfile, tool='partclone', level='gzip'
bn = os.path.basename (imgfile) bn = os.path.basename (imgfile)
IMGFILE = f'{imgdir}/{bn}.{imgtype}' IMGFILE = f'{imgdir}/{bn}.{imgtype}'
if ogIsImageLocked (IMGFILE): if ogIsImageLocked (container=None, imgfile=IMGFILE):
SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_LOCKED, f'{ogGlobals.lang.MSG_IMAGE} {container}, {imgfile}') SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_LOCKED, f'{ogGlobals.lang.MSG_IMAGE} {container}, {imgfile}')
return None return None

1
ogclient/lib/python3/InventoryLib.py
View File

@ -115,7 +115,6 @@ def ogIsEfiActive():
def ogListHardwareInfo(): def ogListHardwareInfo():
ret = '' ret = ''
SystemLib.ogEcho ([], 'info', ogGlobals.lang.MSG_HARDWAREINVENTORY)
# Ejecutar dmidecode y obtener tipo de chasis # Ejecutar dmidecode y obtener tipo de chasis
dmi_out = subprocess.run (['dmidecode', '-s', 'chassis-type'], capture_output=True, text=True).stdout dmi_out = subprocess.run (['dmidecode', '-s', 'chassis-type'], capture_output=True, text=True).stdout
dmi_out = '\n'.join ([ x for x in dmi_out.splitlines() if 'Other' not in x ]) dmi_out = '\n'.join ([ x for x in dmi_out.splitlines() if 'Other' not in x ])

30
ogclient/lib/python3/NetLib.py
View File

@ -39,48 +39,32 @@ def _ogConnect (server, protocol, src, dst, options, readonly):
#@param 2 Abreviatura Unidad Organizativa #@param 2 Abreviatura Unidad Organizativa
#@return Cambio recurso remoto en OGIMG. #@return Cambio recurso remoto en OGIMG.
#*/ #*/
def ogChangeRepo(ip_repo, og_unit=None): def ogChangeRepo (ip_repo):
ogprotocol = os.environ['ogprotocol'] or 'smb' ogprotocol = os.environ.get ('ogprotocol', 'smb')
if og_unit:
SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_GENERIC, 'the og_unit parameter became unsupported')
return None
try: try:
mount = subprocess.run (['mount'], capture_output=True, text=True).stdout mount = subprocess.run (['mount'], capture_output=True, text=True).stdout
ro = bool (list (filter (lambda line: re.search (r'ogimages.*\bro,', line), mount.splitlines()))) ro = bool (list (filter (lambda line: re.search (r'ogimages.*\bro,', line), mount.splitlines())))
current_repo = ogGetRepoIp() current_repo = ogGetRepoIp()
new_repo = current_repo if ip_repo.upper() == "REPO" else ip_repo new_repo = current_repo if ip_repo.upper() == 'REPO' else ip_repo
if new_repo == current_repo: return True if new_repo == current_repo: return True
subprocess.run(["umount", ogGlobals.OGIMG], check=True) subprocess.run (['umount', ogGlobals.OGIMG], check=True)
SystemLib.ogEcho (['session', 'log'], None, f'{ogGlobals.lang.MSG_HELP_ogChangeRepo} {new_repo}') SystemLib.ogEcho (['session', 'log'], None, f'{ogGlobals.lang.MSG_HELP_ogChangeRepo} {new_repo}')
options = _ogConnect_options() options = _ogConnect_options()
if not _ogConnect (new_repo, ogprotocol, 'ogimages', ogGlobals.OGIMG, options, ro): if not _ogConnect (new_repo, ogprotocol, 'ogimages', ogGlobals.OGIMG, options, ro):
_ogConnect (current_repo, ogprotocol, 'ogimages', ogGlobals.OGIMG, options, ro) _ogConnect (current_repo, ogprotocol, 'ogimages', ogGlobals.OGIMG, options, ro)
SystemLib.ogRaiseError( SystemLib.ogRaiseError ('session', ogGlobals.OG_ERR_REPO, f'Error connecting to the new repository: {new_repo}')
"session",
ogGlobals.OG_ERR_REPO,
f"Error connecting to the new repository: {new_repo}",
)
return False return False
SystemLib.ogEcho( SystemLib.ogEcho (['session', 'log'], None, f'Repository successfully changed to {new_repo}'.strip())
["session", "log"],
None,
f"Repository successfully changed to {new_repo}".strip(),
)
return True return True
except Exception as e: except Exception as e:
SystemLib.ogRaiseError( SystemLib.ogRaiseError ('session', ogGlobals.OG_ERR_GENERIC, f'Error executing ogChangeRepo: {e}')
"session",
ogGlobals.OG_ERR_GENERIC,
f"Error executing ogChangeRepo: {e}",
)
return None return None
#/** #/**

15
ogclient/lib/python3/SystemLib.py
View File

@ -13,7 +13,6 @@ from contextlib import redirect_stdout, redirect_stderr
import ogGlobals import ogGlobals
import StringLib import StringLib
import SystemLib
#NODEBUGFUNCTIONS, OGIMG, OG_ERR_CACHESIZE, OG_ERR_NOTCACHE, OG_ERR_NOTWRITE, OG_ERR_FILESYS #NODEBUGFUNCTIONS, OGIMG, OG_ERR_CACHESIZE, OG_ERR_NOTCACHE, OG_ERR_NOTWRITE, OG_ERR_FILESYS
#OG_ERR_REPO, OG_ERR_NOTOS, OG_ERR_NOGPT, OG_ERR_OUTOFLIMIT, OG_ERR_IMAGE, OG_ERR_CACHE #OG_ERR_REPO, OG_ERR_NOTOS, OG_ERR_NOGPT, OG_ERR_OUTOFLIMIT, OG_ERR_IMAGE, OG_ERR_CACHE
@ -66,11 +65,11 @@ def ogEcho (logtypes, loglevel, msg):
#@return Salida de ejecución del comando. #@return Salida de ejecución del comando.
#@note str_logfile = { LOG, SESSION, COMMAND } #@note str_logfile = { LOG, SESSION, COMMAND }
#*/ #*/
#ogHelp (str_logfile ... str_command ...", #ogExecAndLog (str_logfile ... str_command ...",
#ogHelp ([], ogMyLib.ogSomeMethod, *args, **kwargs) #ogExecAndLog ([], ogMyLib.ogSomeMethod, *args, **kwargs)
#ogHelp ('command', ogMyLib.ogSomeMethod, *args, **kwargs) #ogExecAndLog ('command', ogMyLib.ogSomeMethod, *args, **kwargs)
#ogHelp (['command'], ogMyLib.ogSomeMethod, *args, **kwargs) #ogExecAndLog (['command'], ogMyLib.ogSomeMethod, *args, **kwargs)
#ogHelp (['log', 'command'], ogMyLib.ogSomeMethod, *args, **kwargs) #ogExecAndLog (['log', 'command'], ogMyLib.ogSomeMethod, *args, **kwargs)
def ogExecAndLog (logtypes, fun, *args, **kwargs): def ogExecAndLog (logtypes, fun, *args, **kwargs):
logfiles = ['/dev/stdout'] logfiles = ['/dev/stdout']
if type (logtypes) is list: if type (logtypes) is list:
@ -296,11 +295,11 @@ def ogIsRepoLocked():
# FUNCNAME = ogCheckProgram.__name__ # FUNCNAME = ogCheckProgram.__name__
# #
# if not program or not isinstance(program, str): # if not program or not isinstance(program, str):
# SystemLib.ogRaiseError ("session", ogGlobals.OG_ERR_FORMAT, f"Error: {ogGlobals.lang.MSG_ERR_FORMAT} {FUNCNAME} \"program\"") # ogRaiseError ("session", ogGlobals.OG_ERR_FORMAT, f"Error: {ogGlobals.lang.MSG_ERR_FORMAT} {FUNCNAME} \"program\"")
# return # return
# #
# if not shutil.which(program): # if not shutil.which(program):
# SystemLib.ogRaiseError ( "session", ogGlobals.OG_ERR_NOTEXEC, f"Error: The program '{program}' is not available on the system.") # ogRaiseError ( "session", ogGlobals.OG_ERR_NOTEXEC, f"Error: The program '{program}' is not available on the system.")
# return # return
# #
# return 0 # return 0

22
ogclient/lib/python3/UEFILib.py
View File

@ -42,8 +42,8 @@ def ogNvramActiveEntry (entry):
numentries.append (words[0][4:8]) numentries.append (words[0][4:8])
except ValueError: except ValueError:
for l in efibootmgr_out.splitlines(): for l in efibootmgr_out.splitlines():
words = l.split (maxsplit=1) words = l.split (maxsplit=2)
if len(words) < 2: continue if len(words) < 3: continue
if words[1] == entry: if words[1] == entry:
numentries.append (words[0][4:8]) numentries.append (words[0][4:8])
@ -135,8 +135,6 @@ def ogCopyEfiBootLoader (disk, par):
bootlabel = f'Part-{int(disk):02d}-{int(par):02d}' bootlabel = f'Part-{int(disk):02d}-{int(par):02d}'
osversion = InventoryLib.ogGetOsVersion (disk, par) osversion = InventoryLib.ogGetOsVersion (disk, par)
print (f'bootlabel ({bootlabel})')
print (f'osversion ({osversion})')
if 'Windows 1' in osversion: if 'Windows 1' in osversion:
loader = None loader = None
for i in f'{efidir}/EFI/Microsoft/Boot/bootmgfw.efi', f'{efidir}/EFI/{bootlabel}/Boot/bootmgfw.efi': for i in f'{efidir}/EFI/Microsoft/Boot/bootmgfw.efi', f'{efidir}/EFI/{bootlabel}/Boot/bootmgfw.efi':
@ -180,8 +178,8 @@ def ogNvramDeleteEntry (entry):
numentries.append (words[0][4:8]) numentries.append (words[0][4:8])
except ValueError: except ValueError:
for l in efibootmgr_out.splitlines(): for l in efibootmgr_out.splitlines():
words = l.split (maxsplit=1) words = l.split (maxsplit=2)
if len(words) < 2: continue if len(words) < 3: continue
if words[1] == entry: if words[1] == entry:
numentries.append (words[0][4:8]) numentries.append (words[0][4:8])
@ -325,8 +323,8 @@ def ogNvramInactiveEntry (entry):
numentries.append (words[0][4:8]) numentries.append (words[0][4:8])
except ValueError: except ValueError:
for l in efibootmgr_out.splitlines(): for l in efibootmgr_out.splitlines():
words = l.split (maxsplit=1) words = l.split (maxsplit=2)
if len(words) < 2: continue if len(words) < 3: continue
if words[1] == entry: if words[1] == entry:
numentries.append (words[0][4:8]) numentries.append (words[0][4:8])
@ -428,7 +426,7 @@ def ogRestoreEfiBootLoader (disk, par):
return return
osversion = InventoryLib.ogGetOsVersion (disk, par) osversion = InventoryLib.ogGetOsVersion (disk, par)
if 'Windows 1' in osversion: if osversion and 'Windows 1' in osversion:
bootlabel = f'Part-{int(disk):02d}-{int(par):02d}' bootlabel = f'Part-{int(disk):02d}-{int(par):02d}'
loader = FileLib.ogGetPath (file=f'{mntdir}/ogBoot/bootmgfw.efi') loader = FileLib.ogGetPath (file=f'{mntdir}/ogBoot/bootmgfw.efi')
if not loader: if not loader:
@ -487,8 +485,8 @@ def ogNvramSetNext (entry):
numentries.append (words[0][4:8]) numentries.append (words[0][4:8])
except ValueError: except ValueError:
for l in efibootmgr_out.splitlines(): for l in efibootmgr_out.splitlines():
words = l.split (maxsplit=1) words = l.split (maxsplit=2)
if len(words) < 2: continue if len(words) < 3: continue
if words[1] == entry: if words[1] == entry:
numentries.append (words[0][4:8]) numentries.append (words[0][4:8])
@ -496,7 +494,7 @@ def ogNvramSetNext (entry):
SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_NOTFOUND, f'NVRAM entry "{entry}"') SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_NOTFOUND, f'NVRAM entry "{entry}"')
return return
if 1 != len(numentries): if 1 != len (numentries):
SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_GENERIC, f'more than one entry found') SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_GENERIC, f'more than one entry found')
return return

7
ogclient/lib/python3/ogGlobals.py
View File

@ -6,6 +6,10 @@ import os.path
import locale import locale
import importlib.util import importlib.util
## required for defining OGLOGFILE
import NetLib
ip = NetLib.ogGetIpAddress()
def load_lang (name): def load_lang (name):
global lang global lang
if name in sys.modules: if name in sys.modules:
@ -57,11 +61,12 @@ OGBIN = os.path.join (OPENGNSYS, 'bin')
OGETC = os.path.join (OPENGNSYS, 'etc') OGETC = os.path.join (OPENGNSYS, 'etc')
OGLIB = os.path.join (OPENGNSYS, 'lib') OGLIB = os.path.join (OPENGNSYS, 'lib')
OGAPI = os.path.join (OGLIB, 'engine', 'bin') OGAPI = os.path.join (OGLIB, 'engine', 'bin')
OGPYFUNCS = os.path.join (OPENGNSYS, 'functions')
OGSCRIPTS = os.path.join (OPENGNSYS, 'scripts') OGSCRIPTS = os.path.join (OPENGNSYS, 'scripts')
OGIMG = os.path.join (OPENGNSYS, 'images') OGIMG = os.path.join (OPENGNSYS, 'images')
OGCAC = os.path.join (OPENGNSYS, 'cache') OGCAC = os.path.join (OPENGNSYS, 'cache')
OGLOG = os.path.join (OPENGNSYS, 'log') OGLOG = os.path.join (OPENGNSYS, 'log')
OGLOGFILE = f'{OGLOG}/192.168.42.42' ## TODO import NetLib; OGLOGFILE = f'$OGLOG/{NetLib.ogGetIpAddress()}.log' OGLOGFILE = f'{OGLOG}/{ip}.log'
DEBUG = 'yes' DEBUG = 'yes'
_path = os.environ['PATH'] + ':/sbin:/usr/sbin:/usr/local/sbin:/bin:/usr/bin:/usr/local/bin:/opt/oglive/rootfs/opt/drbl/sbin' _path = os.environ['PATH'] + ':/sbin:/usr/sbin:/usr/local/sbin:/bin:/usr/bin:/usr/local/bin:/opt/oglive/rootfs/opt/drbl/sbin'
os.environ['PATH'] = ':'.join ([OGSCRIPTS, _path, OGAPI, OGBIN]) os.environ['PATH'] = ':'.join ([OGSCRIPTS, _path, OGAPI, OGBIN])

57
ogclient/scripts/listHardwareInfo.py
View File

@ -1,43 +1,28 @@
import subprocess #!/usr/bin/python3
# Scirpt de ejemplo para almacenear en fichero temporal el listado de hardware.
# Nota: se usa como base para el programa de recogida de listado de hardware de OpenGnsys Admin.
# Formato: listHardwareInfo
import os import os
import sys import sys
sys.path.append('/opt/opengnsys/lib/engine/bin') import subprocess
import ogGlobals
from SystemLib import ogRaiseError
from NetLib import ogGetIpAddress from NetLib import ogGetIpAddress
sys.path.append('/opt/opengnsys/lib/engine/bin')
from InventoryLib import ogListHardwareInfo from InventoryLib import ogListHardwareInfo
def get_server_log_dir(): prog = sys.argv[0]
# Obtener el directorio de logs del servidor if len (sys.argv) > 1:
oglog = os.getenv("OGLOG") ogRaiseError ([], ogGlobals.OG_ERR_FORMAT, f'{ogGlobals.lang.MSG_FORMAT} {prog}')
if not oglog: sys.exit (1)
return ""
result = subprocess.run(["mount"], capture_output=True, text=True)
for line in result.stdout.splitlines():
parts = line.split()
if len(parts) >= 4 and parts[3] == oglog:
return parts[1]
return ""
def list_hardware_info(): # Directorio del servidor donde se exportan los ficheros de registro.
oglog = os.getenv("OGLOG", "/tmp") # Usar /tmp como valor por defecto para OGLOG #SERVERLOGDIR = unused
ip_address = ogGetIpAddress()
# Fichero de listado de hardware basado en la IP obtenida
hardfile = f"hard-{ogGetIpAddress()}"
print(f"hardfile:{hardfile}")
# Ejecutar ogListHardwareInfo y redirigir al archivo de listado
hardware_info_path = os.path.join(oglog, hardfile)
with open(hardware_info_path, 'w') as output_file:
output_file.write(ogListHardwareInfo())
return hardware_info_path
if __name__ == "__main__":
# Obtener el directorio del servidor donde se exportan los ficheros de registro
server_log_dir = get_server_log_dir()
# Generar el archivo de listado de hardware y obtener su ruta
hardware_info_path = list_hardware_info()
# Imprimir la ruta del archivo generado
print(hardware_info_path)
# Fichero de listado: hard-IP
HARDFILE = f'{ogGlobals.OGLOG}/hard-{ogGetIpAddress()}'
out = ogListHardwareInfo()
with open (HARDFILE, 'w') as fd:
fd.write (out)
print (HARDFILE)

22
ogclient/scripts/updateBootCache.py
View File

@ -1,6 +1,7 @@
#!/usr/bin/python3 #!/usr/bin/python3
import os import os
import sys
import shutil import shutil
import ogGlobals import ogGlobals
@ -34,29 +35,34 @@ if not CacheLib.ogMountCache():
os.makedirs (ogbcache, exist_ok=True) os.makedirs (ogbcache, exist_ok=True)
servervmlinuz = serverinitrd = cachevmlinuz = cacheinitrd = ''
# comparamos los del server # comparamos los del server
with open (f'{ogbtftp}/ogvmlinuz.sum', 'rb') as fd: servervmlinuz = fd.read() if os.path.exists (f'{ogbtftp}/ogvmlinuz.sum'):
with open (f'{ogbtftp}/oginitrd.img.sum', 'rb') as fd: serverinitrd = fd.read() with open (f'{ogbtftp}/ogvmlinuz.sum', 'r') as fd: servervmlinuz = fd.read().strip()
if os.path.exists (f'{ogbtftp}/oginitrd.img.sum'):
with open (f'{ogbtftp}/oginitrd.img.sum', 'r') as fd: serverinitrd = fd.read().strip()
#comparamos los de la cache #comparamos los de la cache
with open (f'{ogbcache}/ogvmlinuz.sum', 'rb') as fd: cachevmlinuz = fd.read() if os.path.exists (f'{ogbcache}/ogvmlinuz.sum'):
with open (f'{ogbcache}/oginitrd.img.sum', 'rb') as fd: cacheinitrd = fd.read() with open (f'{ogbcache}/ogvmlinuz.sum', 'r') as fd: cachevmlinuz = fd.read().strip()
if os.path.exists (f'{ogbcache}/oginitrd.img.sum'):
with open (f'{ogbcache}/oginitrd.img.sum', 'r') as fd: cacheinitrd = fd.read().strip()
print (f'MD5 on SERVER: {servervmlinuz} {serverinitrd}') print (f'MD5 on SERVER: {servervmlinuz} {serverinitrd}')
print (f'MD5 on CACHE: {cachevmlinuz} {cacheinitrd}') print (f'MD5 on CACHE: {cachevmlinuz} {cacheinitrd}')
do_reboot = '0' do_reboot = ''
if cachevmlinuz != servervmlinuz: if cachevmlinuz != servervmlinuz:
print ('ogvmlinuz updating') print ('ogvmlinuz updating')
shutil.copy2 (f'{ogbtftp}/ogvmlinuz', f'{ogbcache}/ogvmlinuz') shutil.copy2 (f'{ogbtftp}/ogvmlinuz', f'{ogbcache}/ogvmlinuz')
shutil.copy2 (f'{ogbtftp}/ogvmlinuz.sum', f'{ogbcache}/ogvmlinuz.sum') shutil.copy2 (f'{ogbtftp}/ogvmlinuz.sum', f'{ogbcache}/ogvmlinuz.sum')
do_reboot = '1' do_reboot = 'true'
if cacheinitrd != serverinitrd: if cacheinitrd != serverinitrd:
print ('oginitrd updating') print ('oginitrd updating')
shutil.copy2 (f'{ogbtftp}/oginitrd.img', f'{ogbcache}/oginitrd.img') shutil.copy2 (f'{ogbtftp}/oginitrd.img', f'{ogbcache}/oginitrd.img')
shutil.copy2 (f'{ogbtftp}/oginitrd.img.sum', f'{ogbcache}/oginitrd.img.sum') shutil.copy2 (f'{ogbtftp}/oginitrd.img.sum', f'{ogbcache}/oginitrd.img.sum')
do_reboot = '1' do_reboot = 'true'
print (do_reboot) print (do_reboot)
os.exit (0) sys.exit (0)