[Python] oppure [/bin/bash] per automatizzare una lista e una priorità

[kata00]

Ciao a tt,
sn nuovo del forum e sto imparando da meno di un anno sia linux che python.
Vi chiedo aiuto perchè nn saprei da dove cominciare e che linguaggio utilizzare.
Spiego cosa vorrei realizzare:
Poniamo che ho 3 programmi in python che svolgono qualcosa: a.py b.py e c.py
vorrei realizzare un programma che, avviato prima a e poi b e poi c, metta in lista i vari (a b c) e attenda il termine di a prima di eseguire b e, poi, di b prima di eseguire c.

Se dovessi azzardare penserei in python usando while true come listener e un "count" come variabile.... bo... brancolo nel buio
Che ne pensate?
Mi date qualche input?
Grazie

[cdimauro]

Cosa intendi con questo: "metta in lista i vari (a b c)"?

[kata00]

Ciao, grazie per l'interessamento
Provo a spiegarlo in altro modo (io lo immagino così...)

Descrizione:
File Programma Master (il prog che vorrei realizzare)
File Programmi Slave :
----------------------------------File Programma A durata 1 minuto
----------------------------------File Programma B durata 2 minuto
----------------------------------File Programma C durata 3 minuto

Svolgimento:
Avvio il Prog Master che rimane in ascolto
All'occorrenza avvio i Prog Slave che vengono attuati in ordine, così come li ho avviati, dal Prog Master che li pone in una coda e li avvia uno alla volta.

Esempio:
Il Prog Master è in ascolto
Avvio A, dopo pochi secondi avvio C e dopo pochi secondi avvio B.
Il Prog Master esegue A e mette in coda, in ordine, prima C e poi B.
Prog A dura 1 minuto.
Passato il minuto, A restituisce al Prog Master che ha terminato.
Il Prog Master guarda in lista, si ritrova trava C e lo avvia.
C dura 3 minuti.
Finito C avvia B.
Ovviamente il Prog Master rimane per tutto il tempo in ascolto e pone eventuali ulteriori Slave in coda di esecuzione (dopo il B che è ultimo)

Il concetto della playlist...
Spero di essere stato chiaro.
Grazie

[cdimauro]

In tal caso potresti sfruttare il modulo subprocess per lanciare programmi esterni (anche se essi stessi in Python) e controllarne l'esecuzione.

Se, invece, i programmi esterni possono essere scritti soltanto in Python, potresti sfruttare il modulo threading per eseguirli in thread diversi (e sempre controllandone l'esecuzione) ma su un solo core, oppure se vuoi sfruttare tutti i core che hai a disposizione ci sarebbe il modulo multiprocessing.

Come vedi, dipende tutto da come pensi di orchestrare i "programmi" da eseguire.

[kata00]

Grazie mille per gli input
Mi metto a studiare e provo a capire meglio come funzionano le alternative che mi hai suggerito.
Il subprocess.call l'ho già incontrato nell'interfacciare un pulsante fisico che faceva lo shutdown del sistema ma a primo sguardo, leggo che subprocess input è vulnerabile di shell injection....

Per il momento ancora grazie

[kata00]

Aggiornamento...

Ho scoperto ed imparato l'uso delle liste (...queste sconosciute ) (bellissime...!!)
vorrei sviluppare l'interazione tra Master e Slave così:
il Master rimane in loop con una lista vuota e una funzione che esegue script (mutevoli);
ogni Slave si aggiunge in lista e passa al Master gli script da eseguire; alla fine dello script si cancella dalla lista;

Che ne pensi come architettura dei programmi?
Dovrebbe essere uno scambio di variabili e sto cercando di studiare variabili locali e globali.
per il momento nn funziona... ma potrebbe funzionare??

[cdimauro]

Se rimani all'interno di Python (e quindi con gli "slave" che sono semplici moduli Python, importati alla bisogna), allora quel che scrivi si può implementare molto facilmente.

Anche il passaggio di variabili diventa veramente banale, e funziona senza problemi. Ma devi cominciare a buttare giù un po' di codice, e mostrare concretamente che problemi hai.

[kata00]

Ciao Mauro, io ci provo...
si...nn sono convinto neanche io di ciò che ho scritto
file principale:

import subprocess

lista=["listavuota"]

i=0

def accoda():
	lista.append(nomefile)
	print "aggiunto alla lista", nomefile

def rimuovi():
	del lista[1]
	print "rimosso dalla lista", nomefile

def processa():
	subprocess.call(argomento)
	print "sto processando", lista[1]

def esegui():
	if (i> 1):
		processa()
		print "in attesa %d argomenti da processare" % i
		processa.wait()
		rimuovi()

accoda()
esegui()

file a:

import time

nomefile=a

def prova():
	["echo", "sto eseguendo programma a"]
	time.sleep(10)

argomento=prova()

Ho cercato una soluzione "universale" senza dover dichiarare in maniera fissa cosa fa il file a e i successivi b,c, d...ecc ma forse questa architettura nn si può fare.
Nn l'ho provato ma credo nn funzioni
In più, la funzione accoda() nn credo sia sempre in ascolto

[cdimauro]

Infatti non funziona, e purtroppo si vede che hai ancora molto da lavorare per imparare a programmare, prima di cimentarti con problemi di questa portata.

Prova a dare un'occhiata ai libri che ho in firma e vedi se riesci a completarli (ci sono anche degli esercizi).