[c2925f1a] | 1 | import sys |
---|
| 2 | import os |
---|
[7260bdc2] | 3 | |
---|
| 4 | from engine.FileSystemLib import * |
---|
| 5 | from engine.SystemLib import * |
---|
| 6 | from engine.FileLib import * |
---|
| 7 | from engine.NetLib import * |
---|
[c2925f1a] | 8 | |
---|
| 9 | def ogUcastSyntax(): |
---|
[7260bdc2] | 10 | FUNCNAME = ogUcastSyntax.__name__ |
---|
[c2925f1a] | 11 | PARM = SESSION = SESSIONPARM = MODE = PORTBASE = PERROR = ADDRESS = TOOL = LEVEL = DEVICE = MBUFFER = SYNTAXSERVER = SYNTAXCLIENT = "" |
---|
| 12 | |
---|
| 13 | # Si se solicita, mostrar ayuda. |
---|
| 14 | if "help" in sys.argv or len(sys.argv) > 2 and sys.argv[2] == "help": |
---|
| 15 | ogHelp(f"{FUNCNAME} SENDPARTITION str_sessionSERVER str_device str_tools str_level", |
---|
| 16 | f"{FUNCNAME} RECEIVERPARTITION str_sessionCLIENT str_device str_tools str_level", |
---|
| 17 | f"{FUNCNAME} SENDFILE str_sessionSERVER str_file", |
---|
| 18 | f"{FUNCNAME} RECEIVERFILE str_sessionCLIENT str_file", |
---|
| 19 | "sessionServer syntax: portbase:ipCLIENT-1:ipCLIENT-2:ipCLIENT-N", |
---|
| 20 | "sessionServer example: 8000:172.17.36.11:172.17.36.12", |
---|
| 21 | "sessionClient syntax: portbase:ipMASTER", |
---|
| 22 | "sessionClient example: 8000:172.17.36.249") |
---|
| 23 | return |
---|
| 24 | PERROR = 0 |
---|
| 25 | |
---|
| 26 | # Error si no se reciben $PARM parámetros. |
---|
| 27 | if "PARTITION" in sys.argv[1]: |
---|
| 28 | PARM = 5 |
---|
| 29 | else: |
---|
| 30 | PARM = 3 |
---|
| 31 | if len(sys.argv) != PARM: |
---|
| 32 | ogRaiseError(OG_ERR_FORMAT, "sin parametros") |
---|
| 33 | return |
---|
| 34 | |
---|
| 35 | # 1er param check |
---|
| 36 | if sys.argv[1] not in ["SENDPARTITION", "sendpartition", "RECEIVERPARTITION", "receiverpartition", "SENDFILE", "sendfile", "RECEIVERFILE", "receiverfile"]: |
---|
| 37 | ogRaiseError(OG_ERR_FORMAT, f"1st param: {sys.argv[1]}") |
---|
| 38 | PERROR = 1 |
---|
| 39 | |
---|
| 40 | # 2º param check |
---|
| 41 | if "SEND" in sys.argv[1]: |
---|
| 42 | MODE = "server" |
---|
| 43 | else: |
---|
| 44 | MODE = "client" |
---|
| 45 | |
---|
| 46 | ######### No controlamos el numero de elementos de la session unicast porque en el master es variable en numero |
---|
| 47 | # TODO: diferenciamos los paramatros especificos de la sessión unicast |
---|
| 48 | # SI: controlamos todos los parametros de la sessión unicast. |
---|
| 49 | # [ $MODE == "client" ] && SESSIONPARM=2 || SESSIONPARM=6 |
---|
| 50 | OIFS = IFS |
---|
| 51 | IFS = ':' |
---|
| 52 | SESSION = sys.argv[2].split(':') |
---|
| 53 | IFS = OIFS |
---|
| 54 | |
---|
| 55 | # [[ ${#SESSION[*]} == $SESSIONPARM ]] || ogRaiseError $OG_ERR_FORMAT "parametros session multicast no completa" || PERROR=2# return $? |
---|
| 56 | |
---|
| 57 | # controlamos el PORTBASE de la sesion. Comun.- |
---|
| 58 | PORTBASE = SESSION[0] |
---|
| 59 | if PORTBASE not in ["8000", "8001", "8002", "8003", "8004", "8005"]: |
---|
| 60 | ogRaiseError(OG_ERR_FORMAT, f"McastSession portbase {SESSION[0]}") |
---|
| 61 | PERROR = 3 |
---|
| 62 | |
---|
| 63 | if MODE == "server": |
---|
| 64 | SIZEARRAY = len(SESSION) |
---|
| 65 | for i in range(1, SIZEARRAY): |
---|
| 66 | ADDRESS += f" -O {SESSION[i]}:{PORTBASE}" |
---|
| 67 | # echo " -O ${SESSION[$i]}:$PORTBASE" |
---|
| 68 | else: |
---|
| 69 | ADDRESS = f"{SESSION[1]}:{PORTBASE}" |
---|
| 70 | |
---|
| 71 | # 3er param check - que puede ser un dispositvo o un fichero. |
---|
| 72 | # [ -n "$(ogGetPath "$3")" ] || ogRaiseError $OG_ERR_NOTFOUND " device or file $3" || PERROR=9 #return $? |
---|
| 73 | DEVICE = sys.argv[3] |
---|
| 74 | |
---|
| 75 | # 4 y 5 param check . solo si es sobre particiones. |
---|
| 76 | if PARM == 5: |
---|
| 77 | # 4 param check |
---|
| 78 | if sys.argv[4] not in ["partclone", "PARTCLONE", "partimage", "PARTIMAGE", "ntfsclone", "NTFSCLONE"]: |
---|
| 79 | ogRaiseError(OG_ERR_NOTFOUND, f" herramienta {sys.argv[4]} no soportada") |
---|
| 80 | PERROR = 10 |
---|
| 81 | TOOL = sys.argv[4] |
---|
| 82 | if sys.argv[5] not in ["lzop", "gzip", "LZOP", "GZIP", "0", "1"]: |
---|
| 83 | ogRaiseError(OG_ERR_NOTFOUND, f" compresor {sys.argv[5]} no valido") |
---|
| 84 | PERROR = 11 |
---|
| 85 | |
---|
| 86 | if PERROR != 0: |
---|
| 87 | ogRaiseError(OG_ERR_UCASTSYNTAXT, f" {PERROR}") |
---|
| 88 | return |
---|
| 89 | |
---|
| 90 | # Generamos la instrucción base de unicast -Envio,Recepcion- |
---|
| 91 | SYNTAXSERVER = f"mbuffer {ADDRESS}" |
---|
| 92 | SYNTAXCLIENT = f"mbuffer -I {ADDRESS}" |
---|
| 93 | |
---|
| 94 | if sys.argv[1] == "SENDPARTITION": |
---|
| 95 | PROG1 = ogCreateImageSyntax(DEVICE, " ", TOOL, LEVEL).split("|")[0].split("|")[2].replace(">", "") |
---|
| 96 | print(f"{PROG1} | {SYNTAXSERVER}") |
---|
| 97 | elif sys.argv[1] == "RECEIVERPARTITION": |
---|
| 98 | COMPRESSOR = ogRestoreImageSyntax(" ", DEVICE, TOOL, LEVEL).split("|")[0] |
---|
| 99 | TOOLS = ogRestoreImageSyntax(" ", DEVICE, TOOL, LEVEL).split("|")[-1] |
---|
| 100 | print(f"{SYNTAXCLIENT} | {COMPRESSOR} | {TOOLS}") |
---|
| 101 | elif sys.argv[1] == "SENDFILE": |
---|
| 102 | print(f"{SYNTAXSERVER} -i {sys.argv[3]}") |
---|
| 103 | elif sys.argv[1] == "RECEIVERFILE": |
---|
| 104 | print(f"{SYNTAXCLIENT} -i {sys.argv[3]}") |
---|
| 105 | # |
---|
| 106 | def ogUcastSendPartition(): |
---|
[7260bdc2] | 107 | FUNCNAME = ogUcastSendPartition.__name__ |
---|
[c2925f1a] | 108 | # Variables locales |
---|
| 109 | PART = COMMAND = RETVAL = "" |
---|
| 110 | |
---|
| 111 | # Si se solicita, mostrar ayuda. |
---|
| 112 | if len(sys.argv) > 1 and sys.argv[1] == "help": |
---|
| 113 | ogHelp(f"{FUNCNAME} int_ndisk int_npart SessionUNICAST-SERVER tools compresor", |
---|
| 114 | f"{FUNCNAME} 1 1 8000:172.17.36.11:172.17.36.12 partclone lzop") |
---|
| 115 | return |
---|
| 116 | |
---|
| 117 | # Error si no se reciben 5 parámetros. |
---|
| 118 | if len(sys.argv) != 6: |
---|
| 119 | ogRaiseError(OG_ERR_FORMAT) |
---|
| 120 | return |
---|
| 121 | |
---|
| 122 | # chequeamos la particion. |
---|
| 123 | PART = ogDiskToDev(sys.argv[2], sys.argv[3]) |
---|
| 124 | if not PART: |
---|
| 125 | return |
---|
| 126 | |
---|
| 127 | ogUnmount(sys.argv[2], sys.argv[3]) |
---|
| 128 | |
---|
| 129 | # generamos la instrucción a ejecutar. |
---|
| 130 | COMMAND = ogUcastSyntax("SENDPARTITION", sys.argv[4], PART, sys.argv[5], sys.argv[6]) |
---|
| 131 | RETVAL = 0 |
---|
| 132 | |
---|
| 133 | if RETVAL > 0: |
---|
| 134 | return RETVAL |
---|
| 135 | else: |
---|
| 136 | print(COMMAND) |
---|
| 137 | eval(COMMAND) |
---|
| 138 | if RETVAL > 0: |
---|
| 139 | ogRaiseError(OG_ERR_UCASTSENDPARTITION) |
---|
| 140 | return RETVAL |
---|
| 141 | # |
---|
| 142 | def ogUcastReceiverPartition(): |
---|
[7260bdc2] | 143 | FUNCNAME = ogUcastReceiverPartition.__name__ |
---|
[c2925f1a] | 144 | # Variables locales |
---|
| 145 | PART = COMMAND = RETVAL = "" |
---|
| 146 | |
---|
| 147 | # Si se solicita, mostrar ayuda. |
---|
| 148 | if len(sys.argv) > 1 and sys.argv[1] == "help": |
---|
| 149 | ogHelp(f"{FUNCNAME} int_ndisk int_npart SessionMulticastCLIENT tools compresor", |
---|
| 150 | f"{FUNCNAME} 1 1 8000:ipMASTER partclone lzop") |
---|
| 151 | return |
---|
| 152 | |
---|
| 153 | # Error si no se reciben 5 parámetros. |
---|
| 154 | if len(sys.argv) != 6: |
---|
| 155 | ogRaiseError(OG_ERR_FORMAT) |
---|
| 156 | return |
---|
| 157 | |
---|
| 158 | # chequeamos la particion. |
---|
| 159 | PART = ogDiskToDev(sys.argv[2], sys.argv[3]) |
---|
| 160 | if not PART: |
---|
| 161 | return |
---|
| 162 | |
---|
| 163 | ogUnmount(sys.argv[2], sys.argv[3]) |
---|
| 164 | |
---|
| 165 | # generamos la instrucción a ejecutar. |
---|
| 166 | COMMAND = ogUcastSyntax("RECEIVERPARTITION", sys.argv[4], PART, sys.argv[5], sys.argv[6]) |
---|
| 167 | RETVAL = 0 |
---|
| 168 | |
---|
| 169 | if RETVAL > 0: |
---|
| 170 | return RETVAL |
---|
| 171 | else: |
---|
| 172 | print(COMMAND) |
---|
| 173 | eval(COMMAND) |
---|
| 174 | if RETVAL > 0: |
---|
| 175 | ogRaiseError(OG_ERR_UCASTRECEIVERPARTITION) |
---|
| 176 | return RETVAL |
---|
| 177 | # |
---|
| 178 | def ogUcastSendFile(): |
---|
[7260bdc2] | 179 | FUNCNAME = ogUcastSendFile.__name__ |
---|
[c2925f1a] | 180 | # Variables locales |
---|
| 181 | ARG = ARGS = SOURCE = TARGET = COMMAND = DEVICE = RETVAL = LOGFILE |
---|
| 182 | |
---|
| 183 | # ARGS usado para controlar ubicación de la sesion multicast |
---|
| 184 | # Si se solicita, mostrar ayuda. |
---|
| 185 | if len(sys.argv) > 1 and sys.argv[1] == "help": |
---|
| 186 | ogHelp(f"{FUNCNAME} [str_REPOSITORY] [int_ndisk int_npart] /Relative_path_file sesionMcast(puerto:ip:ip:ip)", |
---|
| 187 | f"{FUNCNAME} 1 1 /aula1/winxp.img 8000:172.17.36.11:172.17.36.12", |
---|
| 188 | f"{FUNCNAME} REPO /aula1/ubuntu.iso sesionUcast", |
---|
| 189 | f"{FUNCNAME} CACHE /aula1/winxp.img sesionUcast", |
---|
| 190 | f"{FUNCNAME} /opt/opengnsys/images/aula1/hd500.vmx sesionUcast") |
---|
| 191 | return |
---|
| 192 | |
---|
| 193 | ARGS = sys.argv[1:] |
---|
| 194 | if ARGS[0].startswith("/"): |
---|
| 195 | SOURCE = ogGetPath(ARGS[0]) |
---|
| 196 | ARG = 2 |
---|
| 197 | DEVICE = ARGS[0] |
---|
| 198 | elif ARGS[0].isdigit(): |
---|
| 199 | SOURCE = ogGetPath(ARGS[0], ARGS[1], ARGS[2]) |
---|
| 200 | ARG = 4 |
---|
| 201 | DEVICE = f"{ARGS[0]} {ARGS[1]} {ARGS[2]}" |
---|
| 202 | else: |
---|
| 203 | SOURCE = ogGetPath(ARGS[0], ARGS[1]) |
---|
| 204 | ARG = 3 |
---|
| 205 | DEVICE = f"{ARGS[0]} {ARGS[1]}" |
---|
| 206 | |
---|
| 207 | # Error si no se reciben los argumentos ARG necesarios según la opcion. |
---|
| 208 | if len(sys.argv) != ARG: |
---|
| 209 | ogRaiseError(OG_ERR_FORMAT) |
---|
| 210 | return |
---|
| 211 | |
---|
| 212 | # Comprobar fichero origen |
---|
| 213 | if not ogGetPath(SOURCE): |
---|
| 214 | ogRaiseError(OG_ERR_NOTFOUND, f" device or file {DEVICE} not found") |
---|
| 215 | return |
---|
| 216 | |
---|
| 217 | SESSION = sys.argv[ARG] |
---|
| 218 | |
---|
| 219 | # generamos la instrucción a ejecutar. |
---|
| 220 | COMMAND = ogUcastSyntax("SENDFILE", SESSION, SOURCE) |
---|
| 221 | RETVAL = 0 |
---|
| 222 | |
---|
| 223 | if RETVAL > 0: |
---|
| 224 | return RETVAL |
---|
| 225 | else: |
---|
| 226 | print(COMMAND) |
---|
| 227 | eval(COMMAND) |
---|
| 228 | if RETVAL > 0: |
---|
| 229 | ogRaiseError(OG_ERR_UCASTSENDFILE) |
---|
| 230 | return RETVAL |
---|
| 231 | # |
---|
| 232 | def ogMcastSyntax(): |
---|
[7260bdc2] | 233 | FUNCNAME = ogMcastSyntax.__name__ |
---|
[c2925f1a] | 234 | PERROR = 0 |
---|
| 235 | |
---|
| 236 | # Si se solicita, mostrar ayuda. |
---|
| 237 | if "help" in sys.argv or len(sys.argv) > 2 and sys.argv[2] == "help": |
---|
| 238 | ogHelp(f"{FUNCNAME} SENDPARTITION str_sessionSERVER str_device str_tools str_level", |
---|
| 239 | f"{FUNCNAME} RECEIVERPARTITION str_sessionCLIENT str_device str_tools str_level", |
---|
| 240 | f"{FUNCNAME} SENDFILE str_sessionSERVER str_file", |
---|
| 241 | f"{FUNCNAME} RECEIVERFILE str_sessionCLIENT str_file", |
---|
| 242 | "sessionServer syntax: portbase:method:mcastaddress:speed:nclients:ntimeWaitingUntilNclients", |
---|
| 243 | "sessionServer example: 9000:full-duplex|half-duplex|broadcast:239.194.17.36:80M:50:60", |
---|
| 244 | "sessionClient syntax: portbase", |
---|
| 245 | "sessionClient example: 9000", |
---|
| 246 | "sessionClient syntax: portbase:serverIP:TimeOut_session:TimeOut_transmision", |
---|
| 247 | "sessionClient example: 9000:172.17.88.161:40:120") |
---|
| 248 | return |
---|
| 249 | |
---|
| 250 | # BEGIN NUMBERS PARAMETERS CHECK AND SESSION OPTIONS IF CLIENT OR SERVER |
---|
| 251 | if "PARTITION" in sys.argv[1]: |
---|
| 252 | PARM = 5 |
---|
| 253 | else: |
---|
| 254 | PARM = 3 |
---|
| 255 | if len(sys.argv) != PARM: |
---|
| 256 | ogRaiseError(OG_ERR_FORMAT, "sin parametros") |
---|
| 257 | return |
---|
| 258 | |
---|
| 259 | ogCheckStringInGroup(sys.argv[1], "SENDPARTITION sendpartition RECEIVERPARTITION receiverpartition SENDFILE sendfile RECEIVERFILE receiverfile") or ogRaiseError(OG_ERR_FORMAT, f"1st param: {sys.argv[1]}") or PERROR = 1 |
---|
| 260 | |
---|
| 261 | if "SEND" in sys.argv[1]: |
---|
| 262 | MODE = "server" |
---|
| 263 | else: |
---|
| 264 | MODE = "client" |
---|
| 265 | |
---|
| 266 | SESSION = sys.argv[2].split(':') |
---|
| 267 | if MODE == "client": |
---|
| 268 | SESSIONPARM = 1 |
---|
| 269 | else: |
---|
| 270 | SESSIONPARM = 6 |
---|
| 271 | if len(SESSION) != SESSIONPARM: |
---|
| 272 | ogRaiseError(OG_ERR_FORMAT, "parametros session de cliente multicast no completa") or PERROR = 2 |
---|
| 273 | |
---|
| 274 | if MODE == "server": |
---|
| 275 | ogCheckStringInGroup(SESSION[1], "full-duplex FULL-DUPLEX half-duplex HALF-DUPLEX broadcast BROADCAST") or ogRaiseError(OG_ERR_FORMAT, f"McastSession method {SESSION[1]}") or PERROR = 4 |
---|
| 276 | ogCheckIpAddress(SESSION[2]) or ogRaiseError(OG_ERR_FORMAT, f"McastSession address {SESSION[2]}") or PERROR = 5 |
---|
| 277 | ogCheckStringInReg(SESSION[3], "^[0-9]{1,3}\M$") or ogRaiseError(OG_ERR_FORMAT, f"McastSession bitrate {SESSION[3]}") or PERROR = 6 |
---|
| 278 | ogCheckStringInReg(SESSION[4], "^[0-9]{1,10}$") or ogRaiseError(OG_ERR_FORMAT, f"McastSession nclients {SESSION[4]}") or PERROR = 7 |
---|
| 279 | ogCheckStringInReg(SESSION[5], "^[0-9]{1,10}$") or ogRaiseError(OG_ERR_FORMAT, f"McastSession maxtime {SESSION[5]}") or PERROR = 8 |
---|
| 280 | |
---|
| 281 | if PERROR != 0: |
---|
| 282 | ogRaiseError(OG_ERR_MCASTSYNTAXT, f" {PERROR}") |
---|
| 283 | return |
---|
| 284 | # END NUMBERS PARAMETERS CHECK |
---|
| 285 | |
---|
| 286 | # BEGIN SERVER SESSION |
---|
| 287 | if MODE == "server": |
---|
| 288 | PORTBASE = SESSION[0] |
---|
| 289 | METHOD = SESSION[1] |
---|
| 290 | ADDRESS = SESSION[2] |
---|
| 291 | BITRATE = SESSION[3] |
---|
| 292 | NCLIENTS = SESSION[4] |
---|
| 293 | MAXTIME = SESSION[5] |
---|
| 294 | CERROR = "8x8/128" |
---|
| 295 | if "mbuffer" in sys.modules: |
---|
| 296 | MBUFFER = " --pipe 'mbuffer -q -m 20M' " |
---|
| 297 | else: |
---|
| 298 | MBUFFER = "" |
---|
| 299 | SYNTAXSERVER = f"udp-sender {MBUFFER} --nokbd --portbase {PORTBASE} --{METHOD} --mcast-data-address {ADDRESS} --fec {CERROR} --max-bitrate {BITRATE} --ttl 16 --min-clients {NCLIENTS} --max-wait {MAXTIME} --autostart {MAXTIME} --log /tmp/mcast.log" |
---|
| 300 | # END SERVER SESSION |
---|
| 301 | |
---|
| 302 | # BEGIN CLIENT SESSION |
---|
| 303 | if MODE == "client": |
---|
| 304 | PORTBASE = SESSION[0] |
---|
| 305 | if ogCheckIpAddress(SESSION[1]): |
---|
| 306 | SERVERADDRESS = f" --mcast-rdv-address {SESSION[1]}" |
---|
| 307 | else: |
---|
| 308 | REPOIP = ogGetRepoIp() |
---|
| 309 | CLIENTIP = " ".join([addr.split("/")[0] for addr in subprocess.check_output(["ip", "-o", "address", "show", "up"]).decode().splitlines() if "lo" not in addr]) |
---|
| 310 | MASCARA = CLIENTIP.split("/")[1] |
---|
| 311 | CLIENTIP = CLIENTIP.split("/")[0] |
---|
| 312 | RIPBT = "" |
---|
| 313 | IPBT = "" |
---|
| 314 | for i in range(1, 5): |
---|
| 315 | RIP = str(int(REPOIP.split(".")[i-1]) + 256) |
---|
| 316 | RIPB = "" |
---|
| 317 | while RIP > 0: |
---|
| 318 | COCIENTE = RIP // 2 |
---|
| 319 | RESTO = RIP % 2 |
---|
| 320 | RIPB = str(RESTO) + RIPB |
---|
| 321 | RIP = COCIENTE |
---|
| 322 | RIPB = RIPB[1:] |
---|
| 323 | RIPBT += RIPB |
---|
| 324 | IP = str(int(CLIENTIP.split(".")[i-1]) + 256) |
---|
| 325 | IPB = "" |
---|
| 326 | while IP > 0: |
---|
| 327 | COCIENTE = IP // 2 |
---|
| 328 | RESTO = IP % 2 |
---|
| 329 | IPB = str(RESTO) + IPB |
---|
| 330 | IP = COCIENTE |
---|
| 331 | IPB = IPB[1:] |
---|
| 332 | IPBT += IPB |
---|
| 333 | REPOSUBRED = RIPBT[:MASCARA] |
---|
| 334 | CLIENTSUBRED = IPBT[:MASCARA] |
---|
| 335 | if REPOSUBRED == CLIENTSUBRED: |
---|
| 336 | SERVERADDRESS = "" |
---|
| 337 | else: |
---|
| 338 | SERVERADDRESS = f" --mcast-rdv-address {REPOIP}" |
---|
| 339 | if ogCheckStringInReg(SESSION[2], "^[0-9]{1,10}$"): |
---|
| 340 | if SESSION[2] == "0": |
---|
| 341 | STARTTIMEOUT = "" |
---|
| 342 | else: |
---|
| 343 | STARTTIMEOUT = f" --start-timeout {SESSION[2]}" |
---|
| 344 | else: |
---|
| 345 | STARTTIMEOUT = "" |
---|
| 346 | if ogCheckStringInReg(SESSION[3], "^[0-9]{1,10}$"): |
---|
| 347 | if SESSION[3] == "0": |
---|
| 348 | RECEIVERTIMEOUT = "" |
---|
| 349 | else: |
---|
| 350 | RECEIVERTIMEOUT = f" --receive-timeout {SESSION[3]}" |
---|
| 351 | else: |
---|
| 352 | RECEIVERTIMEOUT = "" |
---|
| 353 | if "udp-receiver" not in ISUDPCAST: |
---|
| 354 | STARTTIMEOUT = "" |
---|
| 355 | RECEIVERTIMEOUT = "" |
---|
| 356 | SYNTAXCLIENT = f"udp-receiver {MBUFFER} --portbase {PORTBASE}{SERVERADDRESS}{STARTTIMEOUT}{RECEIVERTIMEOUT} --log /tmp/mcast.log" |
---|
| 357 | # END CLIENT SESSION |
---|
| 358 | |
---|
| 359 | # BEGIN MAIN PROGRAM |
---|
| 360 | if sys.argv[1] == "SENDPARTITION": |
---|
| 361 | PROG1 = ogCreateImageSyntax(DEVICE, " ", TOOL, LEVEL).split("|")[0].split("|")[2].replace(">", "") |
---|
| 362 | print(f"{PROG1} | {SYNTAXSERVER}") |
---|
| 363 | elif sys.argv[1] == "RECEIVERPARTITION": |
---|
| 364 | COMPRESSOR = ogRestoreImageSyntax(" ", DEVICE, TOOL, LEVEL).split("|")[0] |
---|
| 365 | TOOLS = ogRestoreImageSyntax(" ", DEVICE, TOOL, LEVEL).split("|")[-1] |
---|
| 366 | print(f"{SYNTAXCLIENT} | {COMPRESSOR} | {TOOLS}") |
---|
| 367 | elif sys.argv[1] == "SENDFILE": |
---|
| 368 | print(f"{SYNTAXSERVER} --file {sys.argv[3]}") |
---|
| 369 | elif sys.argv[1] == "RECEIVERFILE": |
---|
| 370 | print(f"{SYNTAXCLIENT} --file {sys.argv[3]}") |
---|
| 371 | # END MAIN PROGRAM |
---|
| 372 | # |
---|
| 373 | def ogMcastSendFile(): |
---|
[7260bdc2] | 374 | FUNCNAME = ogMcastSendFile.__name__ |
---|
[c2925f1a] | 375 | # Variables locales |
---|
| 376 | ARGS = ARG = SOURCE = TARGET = COMMAND = DEVICE = RETVAL = LOGFILE |
---|
| 377 | |
---|
| 378 | # LOGFILE = "/tmp/mcast.log" |
---|
| 379 | |
---|
| 380 | # ARGS usado para controlar ubicación de la sesion multicast |
---|
| 381 | # Si se solicita, mostrar ayuda. |
---|
| 382 | if len(sys.argv) > 1 and sys.argv[1] == "help": |
---|
| 383 | ogHelp(f"{FUNCNAME} [str_REPOSITORY] [int_ndisk int_npart] /Relative_path_file sesionMcast", |
---|
| 384 | f"{FUNCNAME} 1 1 /aula1/winxp.img sesionMcast", |
---|
| 385 | f"{FUNCNAME} REPO /aula1/ubuntu.iso sesionMcast", |
---|
| 386 | f"{FUNCNAME} CACHE /aula1/winxp.img sesionMcast", |
---|
| 387 | f"{FUNCNAME} /opt/opengnsys/images/aula1/hd500.vmx sesionMcast") |
---|
| 388 | return |
---|
| 389 | |
---|
| 390 | ARGS = sys.argv[1:] |
---|
| 391 | if ARGS[0].startswith("/"): |
---|
| 392 | SOURCE = ogGetPath(ARGS[0]) |
---|
| 393 | ARG = 2 |
---|
| 394 | DEVICE = ARGS[0] |
---|
| 395 | elif ARGS[0].isdigit(): |
---|
| 396 | SOURCE = ogGetPath(ARGS[0], ARGS[1], ARGS[2]) |
---|
| 397 | ARG = 4 |
---|
| 398 | DEVICE = f"{ARGS[0]} {ARGS[1]} {ARGS[2]}" |
---|
| 399 | else: |
---|
| 400 | SOURCE = ogGetPath(ARGS[0], ARGS[1]) |
---|
| 401 | ARG = 3 |
---|
| 402 | DEVICE = f"{ARGS[0]} {ARGS[1]}" |
---|
| 403 | |
---|
| 404 | # Error si no se reciben los argumentos ARG necesarios según la opcion. |
---|
| 405 | if len(sys.argv) != ARG: |
---|
| 406 | ogRaiseError(OG_ERR_FORMAT) |
---|
| 407 | return |
---|
| 408 | |
---|
| 409 | # Comprobar fichero origen |
---|
| 410 | if not ogGetPath(SOURCE): |
---|
| 411 | ogRaiseError(OG_ERR_NOTFOUND, f" device or file {DEVICE} not found") |
---|
| 412 | return |
---|
| 413 | |
---|
| 414 | SESSION = sys.argv[ARG] |
---|
| 415 | |
---|
| 416 | # generamos la instrucción a ejecutar. |
---|
| 417 | COMMAND = ogMcastSyntax("SENDFILE", SESSION, SOURCE) |
---|
| 418 | RETVAL = 0 |
---|
| 419 | |
---|
| 420 | if RETVAL > 0: |
---|
| 421 | return RETVAL |
---|
| 422 | else: |
---|
| 423 | print(COMMAND) |
---|
| 424 | eval(COMMAND) |
---|
| 425 | if RETVAL > 0: |
---|
| 426 | ogRaiseError(OG_ERR_MCASTSENDFILE) |
---|
| 427 | return RETVAL |
---|
| 428 | # |
---|
| 429 | def ogMcastReceiverFile(): |
---|
| 430 | # Variables locales |
---|
[7260bdc2] | 431 | FUNCNAME = ogMcastReceiverFile.__name__ |
---|
[c2925f1a] | 432 | ARGS = ARG = TARGETDIR = TARGETFILE = COMMAND = "" |
---|
| 433 | |
---|
| 434 | # Si se solicita, mostrar ayuda. |
---|
| 435 | if len(sys.argv) > 1 and sys.argv[1] == "help": |
---|
| 436 | ogHelp(f"{FUNCNAME} [str_portMcast] [[Relative_path_file] | [str_REPOSITORY path_file] | [int_ndisk int_npart path_file]]", |
---|
| 437 | f"{FUNCNAME} 9000 /PS1_PH1.img", |
---|
| 438 | f"{FUNCNAME} 9000 CACHE /aula1/PS2_PH4.img", |
---|
| 439 | f"{FUNCNAME} 9000 1 1 /isos/linux.iso") |
---|
| 440 | return |
---|
| 441 | |
---|
| 442 | ARGS = sys.argv[1:] |
---|
| 443 | if ARGS[1].startswith("/"): |
---|
| 444 | TARGETDIR = ogGetParentPath(ARGS[1]) |
---|
| 445 | ARG = 2 |
---|
| 446 | elif ARGS[1].isdigit(): |
---|
| 447 | TARGETDIR = ogGetParentPath(ARGS[1], ARGS[2], ARGS[3]) |
---|
| 448 | ARG = 4 |
---|
| 449 | else: |
---|
| 450 | TARGETDIR = ogGetParentPath(ARGS[1], ARGS[2]) |
---|
| 451 | ARG = 3 |
---|
| 452 | |
---|
| 453 | # Error si no se reciben los argumentos ARG necesarios según la opcion. |
---|
| 454 | if len(sys.argv) != ARG: |
---|
| 455 | ogRaiseError(OG_ERR_FORMAT, "Parametros no admitidos") |
---|
| 456 | return |
---|
| 457 | |
---|
| 458 | # obtenemos el nombre del fichero a descargar. |
---|
| 459 | TARGETFILE = os.path.basename(ARGS[ARG]) |
---|
| 460 | |
---|
| 461 | # generamos la instrucción a ejecutar. |
---|
| 462 | COMMAND = ogMcastSyntax("RECEIVERFILE", sys.argv[1], f"{TARGETDIR}/{TARGETFILE}") |
---|
| 463 | RETVAL = 0 |
---|
| 464 | |
---|
| 465 | if RETVAL > 0: |
---|
| 466 | return RETVAL |
---|
| 467 | else: |
---|
| 468 | print(COMMAND) |
---|
| 469 | eval(COMMAND) |
---|
| 470 | if RETVAL > 0: |
---|
| 471 | ogRaiseError(OG_ERR_MCASTRECEIVERFILE, TARGETFILE) |
---|
| 472 | return RETVAL |
---|
| 473 | #[ -s "$LOGFILE" ] || return 21 |
---|
| 474 | # |
---|
| 475 | def ogMcastSendPartition(): |
---|
[7260bdc2] | 476 | FUNCNAME = ogMcastSendPartition.__name__ |
---|
[c2925f1a] | 477 | # Variables locales |
---|
| 478 | PART = "" |
---|
| 479 | COMMAND = "" |
---|
| 480 | RETVAL = 0 |
---|
| 481 | |
---|
| 482 | # Si se solicita, mostrar ayuda. |
---|
| 483 | if len(sys.argv) > 1 and sys.argv[1] == "help": |
---|
| 484 | ogHelp(f"{FUNCNAME} int_ndisk int_npart SessionMulticastSERVER tools compresor", |
---|
| 485 | f"{FUNCNAME} 1 1 9000:full-duplex:239.194.37.31:50M:20:2 partclone lzop") |
---|
| 486 | return |
---|
| 487 | |
---|
| 488 | # Error si no se reciben 5 parámetros. |
---|
| 489 | if len(sys.argv) != 6: |
---|
| 490 | ogRaiseError(OG_ERR_FORMAT) |
---|
| 491 | return |
---|
| 492 | |
---|
| 493 | # chequeamos la particion. |
---|
| 494 | PART = ogDiskToDev(sys.argv[2], sys.argv[3]) |
---|
| 495 | if not PART: |
---|
| 496 | return |
---|
| 497 | |
---|
| 498 | ogUnmount(sys.argv[2], sys.argv[3]) |
---|
| 499 | |
---|
| 500 | # generamos la instrucción a ejecutar. |
---|
| 501 | COMMAND = ogMcastSyntax("SENDPARTITION", sys.argv[4], PART, sys.argv[5], sys.argv[6]) |
---|
| 502 | RETVAL = 0 |
---|
| 503 | |
---|
| 504 | if RETVAL > 0: |
---|
| 505 | return RETVAL |
---|
| 506 | else: |
---|
| 507 | print(COMMAND) |
---|
| 508 | eval(COMMAND) |
---|
| 509 | if RETVAL > 0: |
---|
| 510 | ogRaiseError(OG_ERR_MCASTSENDPARTITION) |
---|
| 511 | return RETVAL |
---|
| 512 | # |
---|
| 513 | def ogMcastReceiverPartition(): |
---|
[7260bdc2] | 514 | FUNCNAME = ogMcastReceiverPartition.__name__ |
---|
[c2925f1a] | 515 | # Variables locales |
---|
| 516 | PART = "" |
---|
| 517 | COMMAND = "" |
---|
| 518 | RETVAL = 0 |
---|
| 519 | |
---|
| 520 | # Si se solicita, mostrar ayuda. |
---|
| 521 | if len(sys.argv) > 1 and sys.argv[1] == "help": |
---|
| 522 | ogHelp(f"{FUNCNAME} int_ndisk int_npart SessionMulticastCLIENT tools compresor", |
---|
| 523 | f"{FUNCNAME} 1 1 9000 partclone lzop") |
---|
| 524 | return |
---|
| 525 | |
---|
| 526 | # Error si no se reciben 5 parámetros. |
---|
| 527 | if len(sys.argv) != 6: |
---|
| 528 | ogRaiseError(OG_ERR_FORMAT) |
---|
| 529 | return |
---|
| 530 | |
---|
| 531 | # chequeamos la particion. |
---|
| 532 | PART = ogDiskToDev(sys.argv[2], sys.argv[3]) |
---|
| 533 | if not PART: |
---|
| 534 | return |
---|
| 535 | |
---|
| 536 | ogUnmount(sys.argv[2], sys.argv[3]) |
---|
| 537 | |
---|
| 538 | # generamos la instrucción a ejecutar. |
---|
| 539 | COMMAND = ogMcastSyntax("RECEIVERPARTITION", sys.argv[4], PART, sys.argv[5], sys.argv[6]) |
---|
| 540 | RETVAL = 0 |
---|
| 541 | |
---|
| 542 | if RETVAL > 0: |
---|
| 543 | return RETVAL |
---|
| 544 | else: |
---|
| 545 | print(COMMAND) |
---|
| 546 | eval(COMMAND) |
---|
| 547 | if RETVAL > 0: |
---|
| 548 | ogRaiseError(OG_ERR_MCASTSENDPARTITION) |
---|
| 549 | return RETVAL |
---|
| 550 | # |
---|
| 551 | def ogMcastRequest(): |
---|
| 552 | # Variables locales |
---|
| 553 | FILE = "" |
---|
| 554 | PROTOOPT = "" |
---|
| 555 | PORT = "" |
---|
| 556 | PORTAUX = "" |
---|
| 557 | REPOIP = "" |
---|
| 558 | REPOPORTAUX = "" |
---|
| 559 | REPEAT = 0 |
---|
| 560 | OGUNIT = "$(df|awk '/ogimages/ {print $1}'|cut -d/ -f5)/" |
---|
| 561 | |
---|
| 562 | # Si se solicita, mostrar ayuda. |
---|
| 563 | if len(sys.argv) > 1 and sys.argv[1] == "help": |
---|
| 564 | ogHelp(f"{FUNCNAME} path_filename str_mcastoptions") |
---|
| 565 | return |
---|
| 566 | |
---|
| 567 | # Error si no se reciben 2 parámetros. |
---|
| 568 | if len(sys.argv) != 3: |
---|
| 569 | ogRaiseError(OG_ERR_FORMAT) |
---|
| 570 | return |
---|
| 571 | |
---|
| 572 | FILE = f"{OGUNIT}{sys.argv[1]}" |
---|
| 573 | PROTOOPT = sys.argv[2] |
---|
| 574 | |
---|
| 575 | # TODO: CONTROL PARAMETROS |
---|
| 576 | |
---|
| 577 | PORT = PROTOOPT.split(":")[0] |
---|
| 578 | PORTAUX = str(int(PORT) + 1) |
---|
| 579 | REPOIP = ogGetRepoIp() |
---|
| 580 | REPOPORTAUX = 2009 |
---|
| 581 | REPEAT = 0 |
---|
| 582 | while not nmap -n -sU -p $PORTAUX $REPOIP | grep open: |
---|
| 583 | REPEAT += 1 |
---|
| 584 | if REPEAT >= 6: |
---|
| 585 | ogRaiseError("session log", OG_ERR_PROTOCOLJOINMASTER, f"MULTICAST {FILE} {PROTOOPT} {FILELIST}") |
---|
| 586 | return |
---|
| 587 | print(f"{MSG_SCRIPTS_TASK_START}: hose {REPOIP} {REPOPORTAUX} --out sh -c 'echo -ne START_MULTICAST {FILE} {PROTOOPT}'") |
---|
| 588 | # update-cache: |
---|
| 589 | hose(REPOIP, REPOPORTAUX, "--out sh -c 'echo -ne START_MULTICAST {FILE} {PROTOOPT}'") |
---|
| 590 | # multicas-direct: hose {REPOIP} 2009 --out sh -c 'echo -ne START_MULTICAST /{IMAGE}.img {OPTPROTOCOLO}' |
---|
| 591 | time.sleep(10) |
---|
| 592 | # |
---|