# mettere in coda gl'emerge..... [RISOLTO]

## codadilupo

Ciao... oggi, intorno all'una ho lanciato un 

```
# emerge beepmp
```

All'una e mezza stavo per uscire di casa per venire al lavoro* quando mi é sovvenuto che dovevo ancora emerge un paio di altre cose... uno sguardo veloce a emerge -pv xxx, e scopro che tra le dipendenze ci sono pacchetti dipendenza di beepmp, quindi, non posso lanciarli contemporaneamente, a meno di sperare in un colpo di culo  :Wink: 

Ora, mi son chiesto: é pèossibile "appendere" emerge tardivi, per noi smemoroni  :Wink:  ?

pensavo a uno script, ma non saprei che cosa fargli controllare...

qualche geco particolarmente sgamato ? Morellik  :Wink:  ?

* ahhhhh, come si lavora bene, pero', il sabato pomeriggio... che pace, che calma... che silenzio...   :Shocked:  ... sono soloooooo !!!!!!!!!!!!!!!   :Sad:   :Confused:   :Rolling Eyes:   :Smile:   :Cool: 

CodaLast edited by codadilupo on Sun Mar 14, 2004 3:19 pm; edited 1 time in total

----------

## solka

Io quando devo emergiare piu' pacchetti di solito faccio

```

emerge pacchetto1 && emerge pacchetto2 && emerge pacchetto3 ... && pacchettoN && halt
```

Così spegne anche il pc quando ha terminato...

----------

## Danilo

 *codadilupo wrote:*   

> Ciao... oggi, intorno all'una ho lanciato un 
> 
> ```
> # emerge beepmp
> ```
> ...

 

Soluzione parziale che uso.

Aspetto che inizia il download o il configure/installazione di un pacchetto (mai nelle fasi di fetch/aggiornamento di emerge) poi ctrl-c e 

```
emerge pacchetto && emerge pacch2 &&...
```

Per il check uno script devo provare ma ora sto appunto per uscire  :Smile: 

comunque proverei a wrappare 

```

ps -ef 
```

comunque uno script che fa un check se qualcosa e' in esecuzione dovro' farlo prima o poi sarebbe comodo per il mio lavoro

----------

## solka

Per "bloccare" un emerge basta premere CTRL + Z e successivamente lanciare 

```
fg
```

che riprende il lavoro che hai stoppato...

----------

## codadilupo

forse non mi sono spiegato: lo so bene che se do

```
# emerge -UD primopacchetto
```

e poi CRTL+C, posso fare un bel:

```
# emerge --resume; emerge altropacchettocheavevodimenticato
```

Quello che dicevo era proprio evitare di dover stooppare il primo processo... se stessi compilando OpenOffice non mi divertirebbe granché, vi pare  :Wink: 

La situazione che prospettavo era:

```
# emerge -UD primopacchetto
```

```
# emerge --append altropacchettocheavevodimenticato
```

se si riesce a infilare come opzione in emerge, oppure, banalmente:

```
# append altropacchettocheavevodimenticato
```

come script a se' stante...

E' davvero cosi' sciocco ?  :Rolling Eyes: 

Coda

----------

## xlyz

```
emerge pacchetto1 pacchetto2 pacchetto3
```

----------

## codadilupo

 *xlyz wrote:*   

> 
> 
> ```
> emerge pacchetto1 pacchetto2 pacchetto3
> ```
> ...

 

Ehmm.... credo di aver già risposto a questo.... ma che c'ho oggi ? Parlo ancora un italiano semi-decente, vero ? Oppure mi state facendo un pesce d'aprile... in anticipo  :Laughing:  ?

Mi capite ?

azz, stu' capitt, ka van ghe mess', a l'aujurdui  :Wink:  ??

Coda

----------

## fedeliallalinea

Tu vuoi qualcosa del genere se ho capito bene

```
if pacchetto_finito_compilazione then

  emerge altro_pacchetto_dimenticato

fi
```

Giusto?

----------

## Mithrandir81

beh se vuoler una cosa di quel tipo allora quello che gli hanno suggerito sopra

```

emerge pacchetto1 && emerge pacchetto2 && ...

```

dovrebbe andar bene, con "&&" se il comando precedente non va a buon fine, non esegue il successivo...

----------

## fedeliallalinea

 *Mithrandir81 wrote:*   

> beh se vuoler una cosa di quel tipo allora quello che gli hanno suggerito sopra
> 
> ```
> 
> emerge pacchetto1 && emerge pacchetto2 && ...
> ...

 

No penso che lui dice se ha dimenticato il programma di metterlo in coda(dilupo)  :Very Happy:  .

----------

## Danilo

 *fedeliallalinea wrote:*   

> No penso che lui dice se ha dimenticato il programma di metterlo in coda(dilupo)  .

 

Lui semplicemente non vuole fare uno stop dell'emerge corrente.

Questo perche'  l'emerge corrente potrebbe essere openoffice (ma io aggiungerei uno dei vari kde-media ecc...).

Non ha detto nulla se legare o meno gli emerge successivi dal sucdcesso del precedente.

Codadilupo pazienta un pochino: se ci impegnamo a fondo riusciamo a capirti  :Wink: 

----------

## -YoShi-

Magari dico una cavolata, ma se dai l'emerge del pacchetto che ti sei dimenticato in un altra console?

----------

## fedeliallalinea

Un modo sarebbe quello di scrivere uno script che con ps xa | grep emerge controlli se c'e', se non c'e' allora fa partire il nuovo emerge. Questo script lo mette poi nella crontab.

----------

## fedeliallalinea

 *-YoShi- wrote:*   

> Magari dico una cavolata, ma se dai l'emerge del pacchetto che ti sei dimenticato in un altra console?

 

Potresti avere problemi, metti caso che tutti e due finiscono nello stesso momento e scrivano contemporaneamente nel file world, si crea un caos.

----------

## randomaze

 *-YoShi- wrote:*   

> Magari dico una cavolata, ma se dai l'emerge del pacchetto che ti sei dimenticato in un altra console?

 

Si rischia di incasinare il db degli ebuild

----------

## -YoShi-

Già è vero, ma è raro che 2 pacchetti finiscano nello stesso momento, secondo me ti deve andare di sfiga...

Poi lo script andrebbe lanciato prima di dare l'emerge no? quindi dovresti stoppare il tutto, lanciare lo script e far ripartire...

----------

## fedeliallalinea

 *-YoShi- wrote:*   

> Già è vero, ma è raro che 2 pacchetti finiscano nello stesso momento, secondo me ti deve andare di sfiga...

 

Mica tanto vero.

 *-YoShi- wrote:*   

> Poi lo script andrebbe lanciato prima di dare l'emerge no? quindi dovresti stoppare il tutto, lanciare lo script e far ripartire...

 

E no se no a che serve. Lo lanci se ti dimentichi anche se sta compilando.

----------

## -YoShi-

 *fedeliallalinea wrote:*   

> 
> 
> E no se no a che serve. Lo lanci se ti dimentichi anche se sta compilando.

 

Eheh scusa ma sono un po fuso sta sera, avevo capito giusto ma non mi tronavano i conti. Cmq poi se lo script partisse, analizzasse l'ebuild e cominciasse a compilare il pacchetto dimenticato si avrebbe sempre il problema dei 2 programmi finiti nello stesso momento no?

----------

## fedeliallalinea

 *-YoShi- wrote:*   

> Cmq poi se lo script partisse, analizzasse l'ebuild e cominciasse a compilare il pacchetto dimenticato si avrebbe sempre il problema dei 2 programmi finiti nello stesso momento no?

 

No perche' con ps xa | grep emerge vedi se c'e' un'installazione attiva o no. Il programma partirebbe quando il processo emerge finirebbe.

----------

## Danilo

 *-YoShi- wrote:*   

> Già è vero, ma è raro che 2 pacchetti finiscano nello stesso momento, secondo me ti deve andare di sfiga...
> 
> 

 

Secondo Murphy non piu' di tanto  :Wink: 

Proprio ora vengo da un incasinamento della cache. E gli unici ebuild paralleli che ho fatto era quando su uno dei 2 volevo fare un fetchonly...

Forse ho fatto uno shutdown con un updateDB in corso mah!!!  :Shocked: 

----------

## HexDEF6

prova a scrivere nella console che sta "emergiando" il comando successivo... 

(che spiegazione da schifo!)

esempio hai lanciato 

emerge pippo pluto paperino

ti accorgi (dopo che il tutto e' partito) 

che vuoi anche emergiare paperina (ma ha come dipendenza paperino)

allora senza fare ctrl-c e lanciare 

emerge pippo pluto paperino paperina

scrivi nella stessa console di prima (occhio che lo fai alla cieca e quindi DEVI scrivere giusto!)

emerge paperina (INVIO)

cosi appena e' finito

emerge pippo pluto paperino

parte

emerge paperina

Ciao!

----------

## fedeliallalinea

 *HexDEF6 wrote:*   

> cosi appena e' finito
> 
> emerge pippo pluto paperino
> 
> parte
> ...

 

Non ci avevo pensato e' vero  :Very Happy:  . Comunque lo trovo un po scomodo.

----------

## HexDEF6

 *fedeliallalinea wrote:*   

>  *HexDEF6 wrote:*   cosi appena e' finito
> 
> emerge pippo pluto paperino
> 
> parte
> ...

 

di sicuro non e' una soluzione elegante.... ma funziona!

Ciao!

----------

## fedeliallalinea

Questo scriptino potrebbe funzionare

```
#!/bin/sh

COMMAND=`ps xa | grep emerge | wc -l`

if  [ ${COMMAND} -eq 1 ]; then

    emerge $1

fi
```

Metti nella tua crontab ogni quanto farlo partire e scrivi (il nome dello script non deve contenere il nome emerge)

```
./nome_script nome_programma_da_mergiare
```

fa schifo come script ma per ora e' l'unica cosa che mi e' venuta in mente.

----------

## nomadsoul

salve a tutti.. mi sn appena registrato ...

io ho iniziato a fare così

mi faccio un bel file con nano dato che quando emergo stoppo quasi sempre X (questo pc è il mio desktop  :Very Happy:  )

quindi da root

```
/root# nano -w install.sh
```

l'ultima volta che l'ho fatto stavo reinstallando tutto, poichè c'erano degli sbalzi di tensione sulla mia linea xè vicino a dove abito c'è una ditta che fa anche revisioni a turbine per jet e cose simili e queste sere si stavano divertendo a spingerne una a 46MW invece che 40...

quindi mi sn fatto un bellos cript tipo

```
 

echo started kde_base >> install.log 

date >> install.log

emerge kdebase &&

echo .....done! >> install.log &&

echo started etcetc

```

poi mi è capitato che mentre era in esecuzione la compilazioni di dover aggiungere un pacchetto che mi ero scordato, l'ho messo in fondo ed è andatot utto ok

è stato eseguito dopo tutti gli altri tranquillamente e senza nemmeno spaccarmi il cranio + di tanto

potrebbe essere una soluzione  :Very Happy: 

( i vari echo mi servivano in caso di un altro sbalzo di tensione e crash del pc per vedere dove ero arrivato senza fare le cose alla cieca  :Very Happy:  )

----------

## Gavrila

io uso un metodo molto naif

ctrl-z 

#fg && emerge pacchetto_da_mettere_incoda  :Smile: 

----------

## xlyz

 *Gavrila wrote:*   

> io uso un metodo molto naif
> 
> ctrl-z 
> 
> #fg && emerge pacchetto_da_mettere_incoda 

 

nooo

e' troppo semplice

senza nemmeno uno scriptino in bash o in python

e poi coda l'ha detto chiaramente: non vuole dover schiacciare ctrl-C, ctrl -Z o ctrl-checchessia

 :Cool:   :Razz:   :Very Happy: 

----------

## Gavrila

 *xlyz wrote:*   

>  *Gavrila wrote:*   io uso un metodo molto naif
> 
> ctrl-z 
> 
> #fg && emerge pacchetto_da_mettere_incoda  
> ...

 

Beh tra ctrl-z e ctrl-c direi che c'ce' na bella differenza O_O

----------

## fedeliallalinea

 *Gavrila wrote:*   

> Beh tra ctrl-z e ctrl-c direi che c'ce' na bella differenza O_O

 

Ma coda non vuole fare nessun ctrl-qualsiasi_cosa!!

----------

## Gavrila

 *fedeliallalinea wrote:*   

>  *Gavrila wrote:*   Beh tra ctrl-z e ctrl-c direi che c'ce' na bella differenza O_O 
> 
> Ma coda non vuole fare nessun ctrl-qualsiasi_cosa!!

 

ok ok ho capito....

....

 :Shocked: 

cmq ctrl-z funziona  :Very Happy:   :Very Happy:   :Very Happy: 

----------

## codadilupo

 *Gavrila wrote:*   

> cmq ctrl-z funziona   

 

scusa, ma ctrl-z anche se mi pemrette di riesumare il comando (a differenza di ctrl-c) non credo che mi riprenda la compilazione da dove l'ha interrotta, giusto ?

E, allora, siamo punto e accapo  :Wink: 

Quello che volevo dire (lo so: pensavo di aprire un topic, e invece, "ho creato un mostro"  :Wink: ) é: avete presente i download manager ?

Ecco, piu' o meno cosi'... anche se stai già scaricando qualcosa, puoi sempre appendere alla lista degli scaricandi qualcos'altro ... e quello che aggiungi parte alla fine della lista (quindi dopo gl'altri pacchetti, senza sovrapposizioni che possano creare problemi nel file world e pure nel sandbox: devo dire che m'e' capitato   :Evil or Very Mad:  )

in pratica chiedevo se c'e' la possibilità* di ottenere la situazione

```
# emerge pacchetto1 pacchetto2 pacchetto3 pacchettoN
```

anche "in corsa", cioe', avendo dato solo

```
# emerge pacchetto1 pacchetto2 pacchetto3
```

e volendo aggiungere 

```
pacchettoN
```

 a processo già avviato.....

... spero d'essere riuscito a capirmi, stavolta  :Wink: 

Non pensavo di suscitare tutto questo   :Very Happy: 

P.S.: credo che lo script di fedeliallalinea potrebbe essere una soluzione. Anche quello di nomadsoul.

Quello di fedeli, pero', richiede l'uso di crontab, che é sempre una brutta bestia (almeno per me  :Wink: ), quello di soul, invece... non l'ho capito   :Embarassed: 

vedro' di fare un po' di prove  :Wink: 

*intendiamoci, la possibilità c'e' sempre: il piu' é capire se si puo' ottenere con un rapporto spesa/impresa decente, senza dover riscrivere il kernel   :Laughing: 

Coda

----------

## fedeliallalinea

 *codadilupo wrote:*   

> Quello di fedeli, pero', richiede l'uso di crontab, che é sempre una brutta bestia (almeno per me ), quello di soul, invece... non l'ho capito  

 

E' che non saprei come altro capire quando emerge ha finito piu' che controllare i processi. Una soluzione e' quella di un loop infinito ma questo occupa risorse per niente imho e quindi ho ripiegato su crontab. Magari esiste un comando che viene lanciato quando un processo finisce ma non me ne vengono in mente.

----------

## xlyz

 *codadilupo wrote:*   

>  *Gavrila wrote:*   cmq ctrl-z funziona    
> 
> scusa, ma ctrl-z anche se mi pemrette di riesumare il comando (a differenza di ctrl-c) non credo che mi riprenda la compilazione da dove l'ha interrotta, giusto ?

 

sbagliato

ricominci esattamente da dove eri

al di la' della mia risposta scherzosa, quella di gavrila e' la soluzione più elegante

sempre che tu possa adattarti a sospendere un job con ctrl+z   :Razz: 

----------

## codadilupo

 *xlyz wrote:*   

> ricominci esattamente da dove eri
> 
> al di la' della mia risposta scherzosa, quella di gavrila e' la soluzione più elegante
> 
> sempre che tu possa adattarti a sospendere un job con ctrl+z  

 

ah, ah , ah  :Wink: 

Certo che posso, solo non credevo che ctrl-z fosse come, chesso'... premere scroll lock  :Wink: 

Pensavo, davvero, che si riprendesse dall'ultimo punto utile, quindi dall'inizio dell'ultimo pacchetto in compilazione... non credevo che potesse riprendere dal bit successivo all'ultimo scritto   :Very Happy: 

Ok, provo cmq le altre due soluzioni, che mi piaccino, ma lascio la palma minimalista d.o.c. a gavrila   :Very Happy: 

che dite, si puo' mettere un [RISOLTO] ?

Coda

----------

## nomadsoul

cmq come ti avevo detto io funziona perfettamente per quello che dici te..

```

# nano -w asd

---------------------------------------

emerge openoffice 

---------------------------------------

# sh asd

```

poi bestemmiando perchè ti sei scordato un pacchetto

```

# nano -w asd (mentre è in esecuzione)

---------------------------------------------

emerge openoffice &&

emerge pacchetto_del_cappero

---------------------------------------------

```

gli && fanno partire il processo dopo solo nel caso vada a buon fine il primo.... meglio di cosi..

ora non chiedetemi come fa a funzionare.. so solo che mi ha funzionato.. xè mi è successo esattamente così...

dovevo fare un emerge di un fracco di roba e per ottimizzare il tempo mi sn creato questo script così potevo anche dormire (che lusso! )

```

echo logfile created at >> install.log

date >> install.log

echo started kdebase >> install.log &&

emerge kdebase && 

echo .....done! >> install.log 

echo started kdeadmin >> install.log && 

emerge kdeadmin && 

echo .....done! >> install.log 

echo started kdeartwork >> install.log && 

emerge kdeartwork && 

echo .....done! >> install.log 

echo started kdenetwork >> install.log && 

emerge kdenetwork && 

echo .....done! >> install.log 

echo started kdemultimedia >> install.log && 

emerge kdemultimedia && 

echo .....done! >> install.log 

echo started kdeutils >> install.log && 

emerge kdeutils && 

echo .....done! >> install.log

echo started XWine  >> install.log && 

emerge XWine && 

echo .....done! >> install.log

echo started mplayer >> install.log && 

emerge mplayer && 

echo .....done! >> install.log

echo started mplayer-skins >> install.log && 

emerge mplayer-skins && 

echo .....done! >> install.log

echo started kopete >> install.log && 

emerge kopete && 

echo .....done! >> install.log

echo kvirc started >> install.log && 

emerge kvirc && 

echo .....done!

echo nvidia-kernel started >> install.log && 

emerge nvidia-kernel && 

echo .....done! >> install.log

echo nvidia-glx started >> install.log && 

emerge nvidia-glx && 

echo .....done! >> install.log

echo samba started >> install.log && 

emerge samba && 

echo .....done! >> install.log

echo opera started >> install.log && 

emerge opera && 

echo .....done! >> install.log

echo links started >> install.log && 

emerge links && 

echo .....done! >> install.log

echo kde-i18n started >> install.log && 

export LINGUAS="it" && 

emerge kde-i18n && 

echo ....done! >> install.log

echo gimp started >> install.log && 

emerge gimp && 

echo .....done! >> install.log && 

echo work finished at >> install.log && 

date >> install.log

```

in modo anche da avere uno straccio di log schifossissimo.

ora emerge gimp l'ho inserito mentre lo script era in esecuzione e nel log è stato stampato, e gimp è stato emerso... che volete di +? se poi bisogna farsi delle seghe mentali è un altra storia  :Razz: 

 :Rolling Eyes: 

questo è l'output install.log in pratica  :Very Happy: 

```

logfile created at

Fri Mar 12 04:43:38 UTC 2004

started kdebase

.....done!

started kdeadmin

.....done!

started kdeartwork

.....done!

started kdenetwork

.....done!

started kdemultimedia

.....done!

started kdeutils

.....done!

started XWine

.....done!

started mplayer

.....done!

started mplayer-skins

.....done!

started kopete

.....done!

kvirc started

nvidia-kernel started

.....done!

nvidia-glx started

.....done!

samba started

.....done!

opera started

.....done!

links started

.....done!

kde-i18n started

....done!

gimp started

.....done!

work finished at

Fri Mar 12 23:08:00 UTC 2004

```

----------

## codadilupo

 *nomadsoul wrote:*   

> cmq come ti avevo detto io funziona perfettamente per quello che dici te..

 

Ahhh, ma é quello che facevo quando volevo un *log* di che pacchetti installava il pacchettoPadre  :Wink: 

```
# emerge -UDp pippo >>/etc/pippo.emerge.log
```

non avevo mai provato ad appendere istruzioni "in corsa"  :Wink: 

Ora ho capito ! Mi avevano fuorviato quei install.log che me l'avevano fatto credere.... moooooolto piu' arzigogolato   :Very Happy: 

Invece é di una linearità che spaventa  :Wink: 

Coda

----------

## nomadsoul

 *codadilupo wrote:*   

> 
> 
> Ora ho capito ! Mi avevano fuorviato quei install.log che me l'avevano fatto credere.... moooooolto piu' arzigogolato  
> 
> Invece é di una linearità che spaventa 
> ...

 

eh sono un n00b io  :Very Happy: 

----------

## codadilupo

 *nomadsoul wrote:*   

> eh sono un n00b io 

 

modesto   :Cool: 

Coda

----------

## Gavrila

 *codadilupo wrote:*   

> 
> 
> Ok, provo cmq le altre due soluzioni, che mi piaccino, ma lascio la palma minimalista d.o.c. a gavrila  
> 
> Coda

 

^_^[/img]

----------

