Merge pull request 'Finish boot lib' (#5) from bootlib into main
Reviewed-on: opengnsys/ogclone-engine#5pull/6/head
commit
7d0dafc2a9
|
|
@ -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)
|
||||
|
|
@ -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)
|
||||
|
|
@ -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)
|
||||
|
|
@ -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)
|
||||
|
|
@ -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)
|
||||
|
|
@ -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)
|
||||
|
|
@ -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)
|
||||
|
|
@ -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)
|
||||
|
|
@ -7,7 +7,6 @@ from NetLib import ogChangeRepo
|
|||
|
||||
parser = argparse.ArgumentParser (add_help=False)
|
||||
parser.add_argument ('ip_repo')
|
||||
parser.add_argument ('og_unit', nargs='?', default=None)
|
||||
|
||||
if 2 == len (sys.argv) and 'help' == sys.argv[1]:
|
||||
#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()
|
||||
|
||||
ret = ogChangeRepo (args.ip_repo, args.og_unit)
|
||||
ret = ogChangeRepo (args.ip_repo)
|
||||
if ret is not None:
|
||||
if ret == True: sys.exit (0)
|
||||
elif ret == False: sys.exit (1)
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
@ -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)
|
||||
|
|
@ -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)
|
||||
|
|
@ -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)
|
||||
|
|
@ -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)
|
||||
|
|
@ -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)
|
||||
|
|
@ -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)
|
||||
|
|
@ -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)
|
||||
|
|
@ -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)
|
||||
|
|
@ -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)
|
||||
|
|
@ -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)
|
||||
|
|
@ -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)
|
||||
|
|
@ -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)
|
||||
|
|
@ -1,10 +1,7 @@
|
|||
#!/usr/bin/env python3
|
||||
#!/usr/bin/python3
|
||||
|
||||
import os
|
||||
import sys
|
||||
|
||||
def main():
|
||||
os.system('poweroff')
|
||||
sys.exit(0)
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
os.system ('poweroff')
|
||||
sys.exit (0)
|
||||
|
|
|
|||
|
|
@ -1,54 +1,62 @@
|
|||
#!/usr/bin/env python3
|
||||
#!/usr/bin/python3
|
||||
|
||||
#______________________________________
|
||||
#
|
||||
# PARAMETROS RECIBIDOS DESDE EL CLIENTE
|
||||
# $1 modo (admin, user)
|
||||
#______________________________________
|
||||
|
||||
import os
|
||||
import sys
|
||||
import re
|
||||
import subprocess
|
||||
import NetLib
|
||||
import SystemLib
|
||||
|
||||
def main():
|
||||
if len(sys.argv) != 2:
|
||||
print("Usage: CambiarAcceso.py <mode>")
|
||||
sys.exit(1)
|
||||
import ogGlobals
|
||||
from SystemLib import ogEcho, ogRaiseError, ogIsRepoLocked
|
||||
from NetLib import ogGetRepoIp
|
||||
|
||||
mode = sys.argv[1]
|
||||
repo_ip = NetLib.ogGetRepoIp()
|
||||
# Error si llamada no se realliza desde OpenGnsys Client.
|
||||
prog = sys.argv[0]
|
||||
if len (sys.argv) != 2:
|
||||
print (f'Usage: {prog} <mode>')
|
||||
sys.exit (1)
|
||||
|
||||
if not repo_ip:
|
||||
SystemLib.ogRaiseError("OG_ERR_NOTFOUND", "repo no montado")
|
||||
# Salir si el repositorio está bloquedo (tiene ficheros abiertos).
|
||||
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():
|
||||
SystemLib.ogRaiseError("OG_ERR_LOCKED", f"repo {repo_ip}")
|
||||
# Comprobar protocolo y modo de acceso.
|
||||
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")
|
||||
if proto not in ["nfs", "smb"]:
|
||||
SystemLib.ogRaiseError("OG_ERR_FORMAT", f"protocolo desconocido {proto}")
|
||||
|
||||
if mode == "admin":
|
||||
mount_mode = "rw"
|
||||
elif mode == "user":
|
||||
mount_mode = "ro"
|
||||
else:
|
||||
SystemLib.ogRaiseError("OG_ERR_FORMAT", f"modo desconocido {mode}")
|
||||
|
||||
OGIMG = os.getenv("OGIMG", "/mnt/OGIMG")
|
||||
OGUNIT = os.getenv("OGUNIT", "")
|
||||
if OGUNIT:
|
||||
OGUNIT = f"/{OGUNIT}"
|
||||
|
||||
subprocess.run(["umount", OGIMG], check=True)
|
||||
SystemLib.ogEcho("info", f"Montar repositorio {repo_ip} por {proto} en modo {mode}")
|
||||
|
||||
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()
|
||||
# Desmontar repositorio y volver a montarlo con el modo adecuado.
|
||||
subprocess.run (['umount', ogGlobals.OGIMG])
|
||||
ogEcho ([], 'info', f'Montar repositorio {repoip} por {proto} en modo {mode}')
|
||||
if 'nfs' == proto:
|
||||
subprocess.run (['mount', '-t', 'nfs', f'{repoip}:{ogGlobals.OGIMG}', ogGlobals.OGIMG, '-o', mount_mode])
|
||||
elif 'smb' == proto:
|
||||
pass_option = ''
|
||||
with open ('/scripts/ogfunctions', 'r') as fd:
|
||||
while True:
|
||||
line = fd.readline()
|
||||
if not line: break
|
||||
if not re.search ('^[\t ]*(export )?OPTIONS=', line): continue
|
||||
m = re.search (r'pass=(\w*)', line)
|
||||
if m:
|
||||
pass_option = m.groups (0)[0]
|
||||
break
|
||||
if not pass_option: pass_option = 'og'
|
||||
subprocess.run (['mount.cifs', f'//{repoip}/ogimages', ogGlobals.OGIMG, '-o', f'{mount_mode},serverino,acl,username=opengnsys,password={pass_option}'])
|
||||
|
|
|
|||
|
|
@ -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 subprocess
|
||||
import sys
|
||||
import time
|
||||
import NetLib
|
||||
|
||||
import ogGlobals
|
||||
from SystemLib import ogEcho, ogRaiseError
|
||||
from NetLib import ogGetIpAddress, ogChangeRepo
|
||||
from StringLib import ogCheckIpAddress
|
||||
|
||||
def load_engine_config():
|
||||
engine_config_path = "/opt/opengnsys/etc/engine.cfg"
|
||||
if os.path.exists(engine_config_path):
|
||||
with open(engine_config_path) as f:
|
||||
exec(f.read(), globals())
|
||||
prog = sys.argv[0]
|
||||
if len (sys.argv) < 4:
|
||||
ogRaiseError ([], ogGlobals.OG_ERR_FORMAT, 'Incorrect number of arguments')
|
||||
sys.exit (1)
|
||||
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():
|
||||
open(os.getenv('OGLOGSESSION'), 'w').close()
|
||||
open(os.getenv('OGLOGCOMMAND'), 'w').close()
|
||||
open(f"{os.getenv('OGLOGCOMMAND')}.tmp", 'w').close()
|
||||
start_time = time.time()
|
||||
env_boot = os.getenv ('boot')
|
||||
|
||||
def log_session_start(script_name, args):
|
||||
SystemLib.ogEcho("log session", f"{os.getenv('MSG_INTERFACE_START')} {script_name} {' '.join(args)}")
|
||||
#Load engine configurator from engine.cfg file.
|
||||
#Carga el configurador del engine desde el fichero engine.cfg
|
||||
## (ogGlobals se encarga)
|
||||
|
||||
def log_session_end(retval):
|
||||
SystemLib.ogEcho("log session", f"{os.getenv('MSG_INTERFACE_END')} {retval}")
|
||||
# Clear temporary file used as log track by httpdlog
|
||||
# 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):
|
||||
try:
|
||||
subprocess.check_call(["ping", "-c", "1", ip])
|
||||
return 0
|
||||
except subprocess.CalledProcessError:
|
||||
return 1
|
||||
# Registro de inicio de ejecución
|
||||
ogEcho (['log', 'session'], None, f'{ogGlobals.lang.MSG_INTERFACE_START} {prog} {disk} {par} {imgname} {arg_repo}')
|
||||
|
||||
def create_image(disk_num, partition_num, repo, image_name):
|
||||
if subprocess.call(["which", "createImageCustom"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) == 0:
|
||||
return subprocess.call(["createImageCustom", disk_num, partition_num, repo, f"/{image_name}"])
|
||||
else:
|
||||
return subprocess.call(["createImage", disk_num, partition_num, repo, f"/{image_name}"])
|
||||
# Valor por defecto para el repositorio.
|
||||
repo = arg_repo
|
||||
if not repo: repo = 'REPO'
|
||||
if repo == ogGetIpAddress(): repo = 'CACHE'
|
||||
# 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():
|
||||
if len(sys.argv) != 5:
|
||||
sys.exit(SystemLib.ogRaiseError(OG_ERR_FORMAT, "Incorrect number of arguments"))
|
||||
# Si el destino es REPO y el cliente no está en modo "admin"; activar repositorio para escritura,
|
||||
if 'REPO' == repo and 'admin' != env_boot:
|
||||
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()
|
||||
clear_temp_logs()
|
||||
log_session_start(sys.argv[0], sys.argv[1:])
|
||||
# Cambiar acceso a modo usuario, si es necesario.
|
||||
if 'REPO' == repo and 'admin' != env_boot:
|
||||
subprocess.run ([f'{dirname}/CambiarAcceso.py', 'user'])
|
||||
|
||||
repo = repo if repo else "REPO"
|
||||
if repo == NetLib.ogGetIpAddress():
|
||||
repo = "CACHE"
|
||||
# Registro de fin de ejecución
|
||||
ogEcho (['log', 'session'], None, f'{ogGlobals.lang.MSG_INTERFACE_END} {retval}')
|
||||
|
||||
if ogCheckIpAddress(repo) == 0 or repo == "REPO":
|
||||
OGUNIT = os.getenv('OGUNIT', "")
|
||||
if not NetLib.ogChangeRepo(repo, OGUNIT):
|
||||
sys.exit(SystemLib.ogRaiseError(OG_ERR_NOTFOUND, f"{repo}"))
|
||||
sys.exit (retval)
|
||||
|
||||
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()
|
||||
|
|
|
|||
|
|
@ -1,62 +1,50 @@
|
|||
#!/usr/bin/env python3
|
||||
#!/usr/bin/python3
|
||||
|
||||
import os
|
||||
import time
|
||||
import subprocess
|
||||
import sys
|
||||
import SystemLib
|
||||
|
||||
import ogGlobals
|
||||
from SystemLib import ogEcho, ogRaiseError
|
||||
|
||||
#sys.path.append('/opt/opengnsys/lib/engine/bin')
|
||||
|
||||
def main(script_path):
|
||||
start_time = time.time()
|
||||
print(f"Ejecutando:",script_path)
|
||||
prog = sys.argv[0]
|
||||
if len (sys.argv) != 2:
|
||||
print (f'Usage: {prog} <script_path>')
|
||||
sys.exit (1)
|
||||
|
||||
# Load engine configurator from engine.cfg file.
|
||||
engine_config_path = '/opt/opengnsys/etc/engine.cfg'
|
||||
# if 'OGENGINECONFIGURATE' not in os.environ:
|
||||
# with open(engine_config_path) as f:
|
||||
# exec(f.read(), globals())
|
||||
TIME1 = time.time()
|
||||
script_path = sys.argv[1]
|
||||
|
||||
# Clear temporary file used as log track by httpdlog
|
||||
with open(os.environ['OGLOGSESSION'], 'w') as f:
|
||||
f.write("")
|
||||
with open(os.environ['OGLOGCOMMAND'], 'w') as f:
|
||||
f.write("")
|
||||
# Clear temporary file used as log track by httpdlog
|
||||
# Limpia los ficheros temporales usados como log de seguimiento para httpdlog
|
||||
open (ogGlobals.OGLOGSESSION, 'w').close()
|
||||
open (ogGlobals.OGLOGCOMMAND, 'w').close()
|
||||
|
||||
# Registro de inicio de ejecución
|
||||
SystemLib.ogEcho('log session', f"{os.environ['MSG_INTERFACE_START']} {sys.argv[0]} {' '.join(sys.argv[1:])}")
|
||||
# Registro de inicio de ejecución
|
||||
ogEcho (['log', 'session'], None, f'{ogGlobals.lang.MSG_INTERFACE_START} {prog} {script_path}')
|
||||
|
||||
with open(os.environ['OGLOGFILE'], 'a') as log_file:
|
||||
log_file.write("\n Instrucciones a ejecutar: *****************************\n"
|
||||
with open(script_path.split()[1]) as script_file: # Obtener solo el nombre del script
|
||||
log_file.write(script_file.read()) )
|
||||
with open (ogGlobals.OGLOGFILE, 'a') as logfd:
|
||||
with open (script_path) as scriptfd:
|
||||
logfd.write ('\n Instrucciones a ejecutar: *****************************\n')
|
||||
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.split()[1], 0o755)
|
||||
result = subprocess.run([sys.executable] + script_path.split(), capture_output=True, text=True)
|
||||
ret_val = result.returncode
|
||||
os.chmod (script_path, 0o755)
|
||||
# Si mandamos la salida a OGLOGCOMMAND reescribimos lo que manda el comando.
|
||||
RETVAL = subprocess.run (script_path, capture_output=True, text=True).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
|
||||
if ret_val == 0:
|
||||
SystemLib.ogEcho('log session', f"[100] Duracion de la operacion {int(elapsed_time // 60)}m {int(elapsed_time % 60)}s")
|
||||
else:
|
||||
SystemLib.ogRaiseError('log session', ret_val)
|
||||
SystemLib.ogEcho('log session', 'error "Operacion no realizada"')
|
||||
TIME = time.time() - TIME1
|
||||
if 0 == RETVAL:
|
||||
ogEcho (['log', 'session'], None, f'[100] Duracion de la operacion {int(TIME // 60)}m {int(TIME % 60)}s')
|
||||
else:
|
||||
ogRaiseError (['log', 'session'], RETVAL, '')
|
||||
ogEcho (['log', 'session'], 'error', 'Operacion no realizada')
|
||||
|
||||
# Registro de fin de ejecución
|
||||
SystemLib.ogEcho('log session', f"{os.environ['MSG_INTERFACE_END']} {ret_val}")
|
||||
# Registro de fin de ejecución
|
||||
ogEcho (['log', 'session'], None, f'{ogGlobals.lang.MSG_INTERFACE_END} {RETVAL}')
|
||||
|
||||
sys.exit(ret_val)
|
||||
|
||||
if __name__ == "__main__":
|
||||
if len(sys.argv) != 2:
|
||||
print("Usage: python EjecutarScript.py <script_path>")
|
||||
sys.exit(1)
|
||||
main(sys.argv[1])
|
||||
sys.exit (RETVAL)
|
||||
|
|
|
|||
|
|
@ -1,33 +1,25 @@
|
|||
#!/usr/bin/env python3
|
||||
import subprocess
|
||||
#!/usr/bin/python3
|
||||
# Script de interfaz para guardar en un fichero el inventario de hardware de un cliente.
|
||||
|
||||
import sys
|
||||
import subprocess
|
||||
|
||||
def main(output_file):
|
||||
# Ejecutar el comando `listHardwareInfo.py` y capturar el resultado
|
||||
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
|
||||
with open(file_path, 'r') as input_file, open(output_file, 'w') as output:
|
||||
lines = input_file.readlines()[1:] # Saltar la primera línea
|
||||
output.writelines(lines)
|
||||
import ogGlobals
|
||||
from SystemLib import ogRaiseError
|
||||
|
||||
except subprocess.CalledProcessError as e:
|
||||
print("Error ejecutando listHardwareInfo.py:", e.stderr, file=sys.stderr)
|
||||
sys.exit(e.returncode)
|
||||
except FileNotFoundError as e:
|
||||
print(f"Archivo no encontrado: {e.filename}", file=sys.stderr)
|
||||
sys.exit(1)
|
||||
prog = sys.argv[0]
|
||||
if len (sys.argv) != 2:
|
||||
print (f'Usage: {prog} <output_file>')
|
||||
sys.exit (1)
|
||||
output_file = sys.argv[1]
|
||||
|
||||
if __name__ == "__main__":
|
||||
if len(sys.argv) != 2:
|
||||
print("Uso: python3 InventarioHardware.py <archivo_salida>")
|
||||
sys.exit(1)
|
||||
main(sys.argv[1])
|
||||
listhi_out = subprocess.run ( [f'{ogGlobals.OGSCRIPTS}/listHardwareInfo.py'], capture_output=True, text=True).stdout
|
||||
if listhi_out:
|
||||
inventory_path = listhi_out.splitlines()[0]
|
||||
else:
|
||||
ogRaiseError ([], ogGlobals.OG_ERR_GENERIC, 'listHardwareInfo.py failed')
|
||||
sys.exit (1)
|
||||
|
||||
with open (inventory_path, 'r') as fdin, open (output_file, 'w') as fdout:
|
||||
lines = fdin.readlines()[1:] # 'tail -n +2'
|
||||
fdout.writelines (lines)
|
||||
|
|
|
|||
|
|
@ -1,53 +1,40 @@
|
|||
#!/usr/bin/env python3
|
||||
|
||||
import os
|
||||
import time
|
||||
import shutil
|
||||
import subprocess
|
||||
import sys
|
||||
|
||||
sys.path.append('/opt/opengnsys/lib/engine/bin')
|
||||
import ogGlobals
|
||||
import SystemLib
|
||||
|
||||
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")
|
||||
from SystemLib import ogEcho, ogRaiseError
|
||||
|
||||
if __name__ == "__main__":
|
||||
if len(sys.argv) != 4:
|
||||
print("Usage: python InventarioSoftware.py <arg1> <arg2> <dest_file>")
|
||||
sys.exit(1)
|
||||
main(sys.argv[1], sys.argv[2], sys.argv[3])
|
||||
prog = sys.argv[0]
|
||||
if len (sys.argv) != 4:
|
||||
print (f'Usage: {prog} <disk> <partition> <dest_file>')
|
||||
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')
|
||||
|
|
|
|||
|
|
@ -1,8 +1,7 @@
|
|||
#!/usr/bin/env python3
|
||||
#!/usr/bin/python3
|
||||
|
||||
import os
|
||||
import sys
|
||||
|
||||
def reboot_system():
|
||||
os.system('reboot')
|
||||
|
||||
if __name__ == "__main__":
|
||||
reboot_system()
|
||||
os.system ('reboot')
|
||||
sys.exit (0)
|
||||
|
|
|
|||
|
|
@ -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 subprocess
|
||||
|
||||
if __name__ == "__main__":
|
||||
if len(sys.argv) < 7:
|
||||
print("Usage: python RestaurarImagen.py <disk> <partition> <image_name> <ip> <protocol> <protocol_options> [additional_args...]")
|
||||
sys.exit(1)
|
||||
import ogGlobals
|
||||
|
||||
disk = sys.argv[1]
|
||||
partition = sys.argv[2]
|
||||
image_name = sys.argv[3]
|
||||
ip = sys.argv[4]
|
||||
protocol = sys.argv[5]
|
||||
protocol_options = sys.argv[6]
|
||||
additional_args = sys.argv[7:]
|
||||
if __name__ == '__main__':
|
||||
prog = sys.argv[0]
|
||||
if len (sys.argv) < 7:
|
||||
print (f'Usage: {prog} <disk> <partition> <image_name> <repo_ip> <protocol> <protocol_options> [additional_args...]')
|
||||
sys.exit (1)
|
||||
|
||||
exit_code = deploy_image(ip, image_name, disk, partition, protocol, protocol_options, *additional_args)
|
||||
sys.exit(exit_code)
|
||||
disk, par, imgname, repo, proto, protoopt, *extra = sys.argv[1:]
|
||||
|
||||
rc = subprocess.run ([f'{ogGlobals.OGSCRIPTS}/deployImage.py', repo, imgname, disk, par, proto, protoopt] + extra).returncode
|
||||
sys.exit (rc)
|
||||
|
|
|
|||
|
|
@ -12,6 +12,7 @@ import tempfile
|
|||
import subprocess
|
||||
import shutil
|
||||
import glob
|
||||
import inspect
|
||||
|
||||
import ogGlobals
|
||||
import SystemLib
|
||||
|
|
@ -21,6 +22,7 @@ import DiskLib
|
|||
import InventoryLib
|
||||
import FileLib
|
||||
import UEFILib
|
||||
import CacheLib
|
||||
|
||||
#/**
|
||||
# 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, 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_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.
|
||||
#@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_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.
|
||||
#*/ ##
|
||||
|
||||
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
|
||||
|
|
@ -126,6 +351,17 @@ def ogSetWindowsName (disk, par, name):
|
|||
#@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_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
|
||||
|
|
@ -414,6 +654,9 @@ def ogGrubInstallMbr (disk, par, checkos='FALSE', kernelparam=''):
|
|||
|
||||
if InventoryLib.ogIsEfiActive():
|
||||
esp = DiskLib.ogGetEsp()
|
||||
if not esp:
|
||||
SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_PARTITION, 'ESP')
|
||||
return None
|
||||
efidisk, efipart = esp.split()
|
||||
# Comprobamos que exista ESP y el directorio para ubuntu
|
||||
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.
|
||||
else: # SI Reconfigurar segunda etapa (grub.cfg) == TRUE
|
||||
#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():
|
||||
# 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_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)
|
||||
# (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'])
|
||||
|
|
@ -575,11 +818,14 @@ def ogGrubInstallPartition (disk, par, checkos='FALSE', kernelparam=''):
|
|||
with open (f'{secondstage}{prefixsecondstage}/boot/grub/grub.cfg', 'a') as fd:
|
||||
fd.write (out + '\n')
|
||||
|
||||
#Instalar el grub
|
||||
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/*')):
|
||||
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.copy2 ('/usr/lib/shim/shimx64.efi.signed', f'{efisecondstage}/EFI/{efisubdir}/Boot/shimx64.efi')
|
||||
# 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.
|
||||
#@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.
|
||||
#*/ ##
|
||||
|
||||
|
||||
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
|
||||
#@brief ver ogBootLoaderHidePartitions
|
||||
#@see ogBootLoaderHidePartitions
|
||||
#*/ ##
|
||||
|
||||
#/**
|
||||
# ogBurgHidePartitions num_disk num_part
|
||||
#@brief ver ogBootLoaderHidePartitions
|
||||
#@see ogBootLoaderHidePartitions
|
||||
#*/ ##
|
||||
def ogGrubHidePartitions (disk, par, datadisk=None, datapar=None):
|
||||
return ogBootLoaderHidePartitions (disk, par, datadisk, datapar)
|
||||
|
||||
#/**
|
||||
# ogBootLoaderHidePartitions num_disk num_part
|
||||
|
|
@ -731,23 +1073,89 @@ def ogCleanLinuxDevices (disk, par):
|
|||
#@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
|
||||
#@brief ver ogBootLoaderDeleteEntry
|
||||
#@see ogBootLoaderDeleteEntry
|
||||
#*/
|
||||
|
||||
#/**
|
||||
# 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
|
||||
#*/
|
||||
def ogGrubDeleteEntry (disk, par, diskdel, pardel):
|
||||
return ogBootLoaderDeleteEntry (disk, par, diskdel, pardel)
|
||||
|
||||
#/**
|
||||
# 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 3 Numero del disco del 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)
|
||||
#@exception OG_ERR_FORMAT Use ogGrubDeleteEntry or ogBurgDeleteEntry.
|
||||
#@exception OG_ERR_FORMAT Use ogGrubDeleteEntry
|
||||
#@exception OG_ERR_FORMAT Formato incorrecto.
|
||||
#@exception OG_ERR_NOTFOUND No existe archivo de configuracion del grub.
|
||||
#*/ ##
|
||||
|
||||
#/**
|
||||
# ogBurgInstallMbr int_disk_GRUBCFG int_partition_GRUBCFG
|
||||
#@param bolean_Check_Os_installed_and_Configure_2ndStage true | false[default]
|
||||
#@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
|
||||
#*/ ##
|
||||
def ogBootLoaderDeleteEntry (disk, par, diskdel, pardel):
|
||||
# Nombre de la función que llama a esta.
|
||||
func = inspect.stack()[1][3]
|
||||
|
||||
# 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
|
||||
#@brief ver ogBootLoaderDefaultEntry
|
||||
#@see ogBootLoaderDefaultEntry
|
||||
#*/ ##
|
||||
|
||||
#/**
|
||||
# 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
|
||||
#*/ ##
|
||||
def ogGrubDefaultEntry (disk, par, diskdefault, pardefault):
|
||||
return ogBootLoaderDefaultEntry (disk, par, diskdefault, pardefault)
|
||||
|
||||
#/**
|
||||
# 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_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
|
||||
#@brief ver ogBootLoaderOgliveDefaultEntry
|
||||
#@see ogBootLoaderOgliveDefaultEntry
|
||||
#*/ ##
|
||||
|
||||
#/**
|
||||
# ogBurgOgliveDefaultEntry num_disk num_part
|
||||
#@brief ver ogBootLoaderOgliveDefaultEntry
|
||||
#@see ogBootLoaderOgliveDefaultEntry
|
||||
#*/ ##
|
||||
|
||||
|
||||
#/**
|
||||
# ogRefindOgliveDefaultEntry
|
||||
#@brief ver ogBootLoaderOgliveDefaultEntry
|
||||
#@see ogBootLoaderOgliveDefaultEntry
|
||||
#*/ ##
|
||||
def ogGrubOgliveDefaultEntry (disk, par):
|
||||
return ogBootLoaderOgliveDefaultEntry (disk, par)
|
||||
|
||||
|
||||
#/**
|
||||
|
|
@ -839,6 +1316,49 @@ def ogCleanLinuxDevices (disk, par):
|
|||
#@exception OG_ERR_NOTFOUND Fichero de configuración no encontrado: 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_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
|
||||
#*/ ##
|
||||
|
||||
#/**
|
||||
# ogBurgSetTheme num_disk num_part str_theme
|
||||
#@brief ver ogBootLoaderSetTheme
|
||||
#@see ogBootLoaderSetTheme
|
||||
#*/ ##
|
||||
|
||||
|
||||
#/**
|
||||
# ogRefindSetTheme str_theme
|
||||
#@brief ver ogBootLoaderSetTheme
|
||||
#@see ogBootLoaderSetTheme
|
||||
#*/ ##
|
||||
|
||||
|
||||
#/**
|
||||
# ogBootLoaderSetTheme
|
||||
|
|
@ -896,12 +1442,6 @@ def ogCleanLinuxDevices (disk, par):
|
|||
#@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
|
||||
#@see ogBootLoaderSetTimeOut
|
||||
#*/ ##
|
||||
|
||||
#/**
|
||||
# ogBurgSetTimeOut num_disk num_part str_bolean
|
||||
#@brief ver ogBootLoaderSetTimeOut
|
||||
#@see ogBootLoaderSetTimeOut
|
||||
#*/ ##
|
||||
|
||||
|
||||
#/**
|
||||
# ogRefindSetTimeOut int_timeout_second
|
||||
#@brief ver ogBootLoaderSetTimeOut
|
||||
#@see ogBootLoaderSetTimeOut
|
||||
#*/ ##
|
||||
def ogGrubSetTimeOut (disk, par, timeout):
|
||||
return ogBootLoaderSetTimeOut (disk, par, timeout)
|
||||
|
||||
#/**
|
||||
# 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 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
|
||||
#*/ ##
|
||||
|
||||
#/**
|
||||
# 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.
|
||||
#*/ ##
|
||||
|
||||
# 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
|
||||
#@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_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')
|
||||
|
|
|
|||
|
|
@ -9,7 +9,6 @@ import ogGlobals
|
|||
import SystemLib
|
||||
import DiskLib
|
||||
import FileSystemLib
|
||||
import CacheLib
|
||||
|
||||
#/**
|
||||
# ogCreateCache [int_ndisk] int_partsize
|
||||
|
|
@ -240,8 +239,7 @@ def ogFormatCache():
|
|||
os.makedirs (j, exist_ok=True)
|
||||
|
||||
# Incluir kernel e Initrd del ogLive
|
||||
## como lo llamo sin especificar el path entero?
|
||||
#subprocess.run (['scripts/updateBootCache.py']) ## TODO
|
||||
subprocess.run ([f'{ogGlobals.OGSCRIPTS}/updateBootCache.py'])
|
||||
|
||||
|
||||
#/**
|
||||
|
|
@ -365,5 +363,5 @@ def ogUnmountCache():
|
|||
#@return lo mismo que devuelve initCache
|
||||
#*/ ##
|
||||
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
|
||||
|
|
|
|||
|
|
@ -14,7 +14,6 @@ import ogGlobals
|
|||
import SystemLib
|
||||
import DiskLib
|
||||
import CacheLib
|
||||
import FileSystemLib
|
||||
|
||||
|
||||
#/**
|
||||
|
|
@ -295,7 +294,7 @@ def ogGetFsSize (disk, par, unit='KB'):
|
|||
return
|
||||
|
||||
# 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:
|
||||
result = subprocess.run(["df", "-BK", mnt], capture_output=True, text=True)
|
||||
val = result.stdout.split("\n")[1].split()[1]
|
||||
|
|
@ -895,7 +894,7 @@ def ogGetFreeSize(disk, part, unit='KB'):
|
|||
kk
|
||||
factor = unit2factor[unit.lower()]
|
||||
|
||||
particion = FileSystemLib.ogMount (disk, part)
|
||||
particion = ogMount (disk, part)
|
||||
if not particion:
|
||||
kk
|
||||
df = subprocess.run (['df'], capture_output=True, text=True).stdout
|
||||
|
|
|
|||
|
|
@ -233,7 +233,7 @@ def ogCreateImage (disk, par, container, imgfile, tool='partclone', level='gzip'
|
|||
|
||||
bn = os.path.basename (imgfile)
|
||||
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}')
|
||||
return None
|
||||
|
||||
|
|
|
|||
|
|
@ -115,7 +115,6 @@ def ogIsEfiActive():
|
|||
def ogListHardwareInfo():
|
||||
ret = ''
|
||||
|
||||
SystemLib.ogEcho ([], 'info', ogGlobals.lang.MSG_HARDWAREINVENTORY)
|
||||
# Ejecutar dmidecode y obtener tipo de chasis
|
||||
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 ])
|
||||
|
|
|
|||
|
|
@ -39,48 +39,32 @@ def _ogConnect (server, protocol, src, dst, options, readonly):
|
|||
#@param 2 Abreviatura Unidad Organizativa
|
||||
#@return Cambio recurso remoto en OGIMG.
|
||||
#*/
|
||||
def ogChangeRepo(ip_repo, og_unit=None):
|
||||
ogprotocol = os.environ['ogprotocol'] or 'smb'
|
||||
|
||||
if og_unit:
|
||||
SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_GENERIC, 'the og_unit parameter became unsupported')
|
||||
return None
|
||||
def ogChangeRepo (ip_repo):
|
||||
ogprotocol = os.environ.get ('ogprotocol', 'smb')
|
||||
|
||||
try:
|
||||
mount = subprocess.run (['mount'], capture_output=True, text=True).stdout
|
||||
ro = bool (list (filter (lambda line: re.search (r'ogimages.*\bro,', line), mount.splitlines())))
|
||||
|
||||
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
|
||||
|
||||
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}')
|
||||
options = _ogConnect_options()
|
||||
if not _ogConnect (new_repo, ogprotocol, 'ogimages', ogGlobals.OGIMG, options, ro):
|
||||
_ogConnect (current_repo, ogprotocol, 'ogimages', ogGlobals.OGIMG, options, ro)
|
||||
SystemLib.ogRaiseError(
|
||||
"session",
|
||||
ogGlobals.OG_ERR_REPO,
|
||||
f"Error connecting to the new repository: {new_repo}",
|
||||
)
|
||||
SystemLib.ogRaiseError ('session', ogGlobals.OG_ERR_REPO, f'Error connecting to the new repository: {new_repo}')
|
||||
return False
|
||||
|
||||
SystemLib.ogEcho(
|
||||
["session", "log"],
|
||||
None,
|
||||
f"Repository successfully changed to {new_repo}".strip(),
|
||||
)
|
||||
SystemLib.ogEcho (['session', 'log'], None, f'Repository successfully changed to {new_repo}'.strip())
|
||||
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
SystemLib.ogRaiseError(
|
||||
"session",
|
||||
ogGlobals.OG_ERR_GENERIC,
|
||||
f"Error executing ogChangeRepo: {e}",
|
||||
)
|
||||
SystemLib.ogRaiseError ('session', ogGlobals.OG_ERR_GENERIC, f'Error executing ogChangeRepo: {e}')
|
||||
return None
|
||||
|
||||
#/**
|
||||
|
|
|
|||
|
|
@ -13,7 +13,6 @@ from contextlib import redirect_stdout, redirect_stderr
|
|||
|
||||
import ogGlobals
|
||||
import StringLib
|
||||
import SystemLib
|
||||
|
||||
#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
|
||||
|
|
@ -66,11 +65,11 @@ def ogEcho (logtypes, loglevel, msg):
|
|||
#@return Salida de ejecución del comando.
|
||||
#@note str_logfile = { LOG, SESSION, COMMAND }
|
||||
#*/
|
||||
#ogHelp (str_logfile ... str_command ...",
|
||||
#ogHelp ([], ogMyLib.ogSomeMethod, *args, **kwargs)
|
||||
#ogHelp ('command', ogMyLib.ogSomeMethod, *args, **kwargs)
|
||||
#ogHelp (['command'], ogMyLib.ogSomeMethod, *args, **kwargs)
|
||||
#ogHelp (['log', 'command'], ogMyLib.ogSomeMethod, *args, **kwargs)
|
||||
#ogExecAndLog (str_logfile ... str_command ...",
|
||||
#ogExecAndLog ([], ogMyLib.ogSomeMethod, *args, **kwargs)
|
||||
#ogExecAndLog ('command', ogMyLib.ogSomeMethod, *args, **kwargs)
|
||||
#ogExecAndLog (['command'], ogMyLib.ogSomeMethod, *args, **kwargs)
|
||||
#ogExecAndLog (['log', 'command'], ogMyLib.ogSomeMethod, *args, **kwargs)
|
||||
def ogExecAndLog (logtypes, fun, *args, **kwargs):
|
||||
logfiles = ['/dev/stdout']
|
||||
if type (logtypes) is list:
|
||||
|
|
@ -296,11 +295,11 @@ def ogIsRepoLocked():
|
|||
# FUNCNAME = ogCheckProgram.__name__
|
||||
#
|
||||
# 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
|
||||
#
|
||||
# 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 0
|
||||
|
|
|
|||
|
|
@ -42,8 +42,8 @@ def ogNvramActiveEntry (entry):
|
|||
numentries.append (words[0][4:8])
|
||||
except ValueError:
|
||||
for l in efibootmgr_out.splitlines():
|
||||
words = l.split (maxsplit=1)
|
||||
if len(words) < 2: continue
|
||||
words = l.split (maxsplit=2)
|
||||
if len(words) < 3: continue
|
||||
if words[1] == entry:
|
||||
numentries.append (words[0][4:8])
|
||||
|
||||
|
|
@ -135,8 +135,6 @@ def ogCopyEfiBootLoader (disk, par):
|
|||
|
||||
bootlabel = f'Part-{int(disk):02d}-{int(par):02d}'
|
||||
osversion = InventoryLib.ogGetOsVersion (disk, par)
|
||||
print (f'bootlabel ({bootlabel})')
|
||||
print (f'osversion ({osversion})')
|
||||
if 'Windows 1' in osversion:
|
||||
loader = None
|
||||
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])
|
||||
except ValueError:
|
||||
for l in efibootmgr_out.splitlines():
|
||||
words = l.split (maxsplit=1)
|
||||
if len(words) < 2: continue
|
||||
words = l.split (maxsplit=2)
|
||||
if len(words) < 3: continue
|
||||
if words[1] == entry:
|
||||
numentries.append (words[0][4:8])
|
||||
|
||||
|
|
@ -325,8 +323,8 @@ def ogNvramInactiveEntry (entry):
|
|||
numentries.append (words[0][4:8])
|
||||
except ValueError:
|
||||
for l in efibootmgr_out.splitlines():
|
||||
words = l.split (maxsplit=1)
|
||||
if len(words) < 2: continue
|
||||
words = l.split (maxsplit=2)
|
||||
if len(words) < 3: continue
|
||||
if words[1] == entry:
|
||||
numentries.append (words[0][4:8])
|
||||
|
||||
|
|
@ -428,7 +426,7 @@ def ogRestoreEfiBootLoader (disk, par):
|
|||
return
|
||||
|
||||
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}'
|
||||
loader = FileLib.ogGetPath (file=f'{mntdir}/ogBoot/bootmgfw.efi')
|
||||
if not loader:
|
||||
|
|
@ -487,8 +485,8 @@ def ogNvramSetNext (entry):
|
|||
numentries.append (words[0][4:8])
|
||||
except ValueError:
|
||||
for l in efibootmgr_out.splitlines():
|
||||
words = l.split (maxsplit=1)
|
||||
if len(words) < 2: continue
|
||||
words = l.split (maxsplit=2)
|
||||
if len(words) < 3: continue
|
||||
if words[1] == entry:
|
||||
numentries.append (words[0][4:8])
|
||||
|
||||
|
|
@ -496,7 +494,7 @@ def ogNvramSetNext (entry):
|
|||
SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_NOTFOUND, f'NVRAM entry "{entry}"')
|
||||
return
|
||||
|
||||
if 1 != len(numentries):
|
||||
if 1 != len (numentries):
|
||||
SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_GENERIC, f'more than one entry found')
|
||||
return
|
||||
|
||||
|
|
|
|||
|
|
@ -6,6 +6,10 @@ import os.path
|
|||
import locale
|
||||
import importlib.util
|
||||
|
||||
## required for defining OGLOGFILE
|
||||
import NetLib
|
||||
ip = NetLib.ogGetIpAddress()
|
||||
|
||||
def load_lang (name):
|
||||
global lang
|
||||
if name in sys.modules:
|
||||
|
|
@ -57,11 +61,12 @@ OGBIN = os.path.join (OPENGNSYS, 'bin')
|
|||
OGETC = os.path.join (OPENGNSYS, 'etc')
|
||||
OGLIB = os.path.join (OPENGNSYS, 'lib')
|
||||
OGAPI = os.path.join (OGLIB, 'engine', 'bin')
|
||||
OGPYFUNCS = os.path.join (OPENGNSYS, 'functions')
|
||||
OGSCRIPTS = os.path.join (OPENGNSYS, 'scripts')
|
||||
OGIMG = os.path.join (OPENGNSYS, 'images')
|
||||
OGCAC = os.path.join (OPENGNSYS, 'cache')
|
||||
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'
|
||||
_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])
|
||||
|
|
|
|||
|
|
@ -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 sys
|
||||
sys.path.append('/opt/opengnsys/lib/engine/bin')
|
||||
import subprocess
|
||||
|
||||
import ogGlobals
|
||||
from SystemLib import ogRaiseError
|
||||
from NetLib import ogGetIpAddress
|
||||
sys.path.append('/opt/opengnsys/lib/engine/bin')
|
||||
from InventoryLib import ogListHardwareInfo
|
||||
|
||||
def get_server_log_dir():
|
||||
# Obtener el directorio de logs del servidor
|
||||
oglog = os.getenv("OGLOG")
|
||||
if not oglog:
|
||||
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 ""
|
||||
prog = sys.argv[0]
|
||||
if len (sys.argv) > 1:
|
||||
ogRaiseError ([], ogGlobals.OG_ERR_FORMAT, f'{ogGlobals.lang.MSG_FORMAT} {prog}')
|
||||
sys.exit (1)
|
||||
|
||||
def list_hardware_info():
|
||||
oglog = os.getenv("OGLOG", "/tmp") # Usar /tmp como valor por defecto para OGLOG
|
||||
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)
|
||||
# Directorio del servidor donde se exportan los ficheros de registro.
|
||||
#SERVERLOGDIR = unused
|
||||
|
||||
# Fichero de listado: hard-IP
|
||||
HARDFILE = f'{ogGlobals.OGLOG}/hard-{ogGetIpAddress()}'
|
||||
out = ogListHardwareInfo()
|
||||
with open (HARDFILE, 'w') as fd:
|
||||
fd.write (out)
|
||||
print (HARDFILE)
|
||||
|
|
|
|||
|
|
@ -1,6 +1,7 @@
|
|||
#!/usr/bin/python3
|
||||
|
||||
import os
|
||||
import sys
|
||||
import shutil
|
||||
|
||||
import ogGlobals
|
||||
|
|
@ -34,29 +35,34 @@ if not CacheLib.ogMountCache():
|
|||
|
||||
os.makedirs (ogbcache, exist_ok=True)
|
||||
|
||||
servervmlinuz = serverinitrd = cachevmlinuz = cacheinitrd = ''
|
||||
# comparamos los del server
|
||||
with open (f'{ogbtftp}/ogvmlinuz.sum', 'rb') as fd: servervmlinuz = fd.read()
|
||||
with open (f'{ogbtftp}/oginitrd.img.sum', 'rb') as fd: serverinitrd = fd.read()
|
||||
if os.path.exists (f'{ogbtftp}/ogvmlinuz.sum'):
|
||||
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
|
||||
with open (f'{ogbcache}/ogvmlinuz.sum', 'rb') as fd: cachevmlinuz = fd.read()
|
||||
with open (f'{ogbcache}/oginitrd.img.sum', 'rb') as fd: cacheinitrd = fd.read()
|
||||
if os.path.exists (f'{ogbcache}/ogvmlinuz.sum'):
|
||||
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 CACHE: {cachevmlinuz} {cacheinitrd}')
|
||||
|
||||
do_reboot = '0'
|
||||
do_reboot = ''
|
||||
if cachevmlinuz != servervmlinuz:
|
||||
print ('ogvmlinuz updating')
|
||||
shutil.copy2 (f'{ogbtftp}/ogvmlinuz', f'{ogbcache}/ogvmlinuz')
|
||||
shutil.copy2 (f'{ogbtftp}/ogvmlinuz.sum', f'{ogbcache}/ogvmlinuz.sum')
|
||||
do_reboot = '1'
|
||||
do_reboot = 'true'
|
||||
|
||||
if cacheinitrd != serverinitrd:
|
||||
print ('oginitrd updating')
|
||||
shutil.copy2 (f'{ogbtftp}/oginitrd.img', f'{ogbcache}/oginitrd.img')
|
||||
shutil.copy2 (f'{ogbtftp}/oginitrd.img.sum', f'{ogbcache}/oginitrd.img.sum')
|
||||
do_reboot = '1'
|
||||
do_reboot = 'true'
|
||||
|
||||
print (do_reboot)
|
||||
os.exit (0)
|
||||
sys.exit (0)
|
||||
|
|
|
|||
Loading…
Reference in New Issue