[linux] at command uitleg

[RSD]

Ik kwam het commando at tegen en las dat het erg fijn is om commando's op een later tijdstip te laten uitvoeren. Echter nu ben ik op zoek naar een soort queue die commando's na elkaar uitvoert en niet tegelijkertijd. Nu is de werking van het commando me niet helemaal duidelijk. Stel dat ik het volgende doe:

Ik doe:

command1 | at now (de uitvoering duurt ongeveer 50 minuten van dat commando)

10 minuten later gebeurt het volgende:

command2 | at now (???)

Nu ben ik benieuwd of command2 meteen wordt uitgevoerd of dat deze pas wordt uitgevoerd, nadat command1 is uitgevoerd. Command1 en command2 mogen dus niet tegelijkertijd worden uitgevoerd. Ik heb al verschillende manuals gelezen, maar het is me niet echt duidelijk.

[NMe]

Ben je niet gewoon op zoek naar een scheduler en dus naar cron?

[LinuX-TUX]

Met NMe. Scheduling kan je beter met cron en consorten doen. Wil je bij je huidige manier blijven, zou ik gewoon een scriptje los schrijven waarin bv

Bash:

#!/bin/sh
command1 && command2

staat en op jouw manier runnen. Dan worden ze sequentieel uitgevoerd en als de eerste niet succesvol is, dan wordt de tweede ook niet uit gevoerd

[Osiris]

RSD schreef op donderdag 24 november 2011 @ 19:43:
Nu is de werking van het commando me niet helemaal duidelijk.

`man at`

[RSD]

Nee ik ben niet op zoek naar cron, ik wil een soort queue bij houden en de commando's zijn elke keer weer anders. In ieder geval de argumenten van de commando's. De commando's moeten ook meteen uitgevoerd worden en er mag maar 1 commando tegelijk uitgevoerd worden en als die klaar is mag de volgende beginnen. Er moet dus een queue bijgehouden worden. Nu kan ik wel in mysql zoiets gaan bijhouden, maar dat is niet zo fijn denk ik.

[Mar2zz]

Dan rammel je ze toch zo in de commandline:
command1 + args && command 2 + args
En als de een niet afhankelijk van de ander's succes moet zijn:
command 1 +args; command2 + args; etc

[RSD]

De commando's worden via php ingevoerd, dus niet via een commandline.

[Osiris]

Dus als ik het goed begrijp doe je nu het volgende:

Je start commando1 welke bepaalde handelingen doet, vervolgens in de queue kijkt wat er na 'zichzelf' gedraait moet worden, bakt daar een command van mét wederom een `| at now` erachteraan en output die naar stdout, zodat die opgepakt wordt door de `at` die je van te voren al in de command-line had ingevuld en vervolgens doet commando2 hetzelfde (naar de queue kijken, command genereren, outputten naar stdout en weer hetzelfde).

Waar loop je nu tegenaan dan?

[webfreakz.nl]

Wikipedia: at (Unix)

http://pwet.fr/man/linux/commandes/posix/at

Iets als:

echo "test" | at now +1 hour

Werkt niet?

[RSD]

Nee, momenteel doe ik het zo. Het php script dat na elkaar gedraaid moet worden, checked om de 10 seconden of het commando nog draait en zo nee, dan mag hij starten en zo ja, dan moet hij over 10 sec weer checken. Dat is niet echt netjes.

Ik wil het eigenlijk zo hebben dat hij een command uitvoert en als deze klaar is, dat het volgende commando uitgevoerd wordt, als die aanwezig is.

[webfreakz.nl]

Heb je niet iets aan Gearman of Beanstalkd?

edit:

RSD schreef op donderdag 24 november 2011 @ 21:29:
Ik wil het eigenlijk zo hebben dat hij een command uitvoert en als deze klaar is, dat het volgende commando uitgevoerd wordt

Dat is toch standaard het geval?

, als die aanwezig is.

"aanwezig" ? Wie? Wat? Waar? Leg uit.

http://www.mkssoftware.com/docs/man1/at.1.asp < Fatsoenlijke time specifications.

[ Voor 89% gewijzigd door webfreakz.nl op 24-11-2011 21:33 ]

[Osiris]

En "het commando" is iets wat je zelf gebakken hebt?

En hoe zag jij zelf het commando `at` in je verhaal tevoorschijn komen?

Hoe wordt dat "Het php script" nu steeds uitgevoerd dan?

Je vertelt maar kleine stukjes van je opzet, je doel et cetera. Dat mag wel wat duidelijker en gestructureerde w.m.b.

[RSD]

het ph script wordt nu door een ander php script uitgevoerd.

Dus zoiets als:

<?php
exec("/usr/local/bin/php blabla.php");
?>

En in blabla.php heb ik bovenaan iets wat continue controleert of een ander process aan het draaien is welke in blabla.php wordt opgestart.

Ik kan naar at gewoon commando's pipen. Maar ik weer dus niet als ik een commando toevoeg of hij deze achteraan in de rij zet of ook meteen gaat uitvoeren.

Wat ik wil is dat als een gebruiker een video upload dat deze meteen wordt geconverteerd, maar er mag niet meer dan 1 conversie per keer plaatsvinden ivm resources. Dus als er achter elkaar wtee video;s worden geupload, moet de laatst geuploade even wachten. Dat is zeg maar het doel!

[ Voor 24% gewijzigd door RSD op 24-11-2011 22:24 ]

[CAPSLOCK2000]

Vergeet 'at'. 'at' gebruik je alleen als je op een specifieke tijd, eenmalig, een commando wil laten uitvoeren. Ik geloof niet dat er een programma is dat precies doet wat jij wil, je zal zelf een scriptje moeten schrijven.

[Loen]

Tsja, makkelijkste is voor elk filmpje een entry in een file te zetten en een loopje maken die die file controleert, idd elke 10 seconden of zo...

Quick en dirty:

while true
do
for mov in 'cat file'
do
convertcommando $mov
cat file | grep -v $mov > file2
mv file2 file
done
mov=""
sleep 10
done


Nu ken ik trouwens totaal geen php, maar als ik je goed begrijp kan je toch gewoon in je convert script de controle doen of er al een convert draait? Dan heb je kans dat er op een gegeven moment meerdere draaien, maar die sleepen dan toch voornamelijk op 1 na..

wordt volgordelijkheid wel lastig natuurlijk maar goed...

[ Voor 31% gewijzigd door Loen op 24-11-2011 23:21 ]

[RSD]

Jah ik heb al iets dat werkt, zoals ik beschreef. Deze laat elke conversie wachten totdat een proces niet meer draait en de eerst volgende die als eerste kijkt, begint dan met converteren.

Echter dacht ik het commando at tegen te komen, maar ik ben niet zeker van de functionaliteit van het commando. Het zag er wel veelbelovend uit. Een soort van queue met commando's die na elkaar worden uitgevoerd en niet opeens allemaal tegelijkertijd.

[H!GHGuY]

Waarom allemaal zo moeilijk maken?

Bash:

[ ! -p /tmp/jobqueue ] && { rm /tmp/jobqueue; mkfifo /tmp/jobqueue; }

while read COMMAND
do
  eval $COMMAND
done < /tmp/jobqueue

En dan laat je je php-script de commando's in die pipe wegschrijven.

[Sendy]

Ik heb weleens een mp3-jukebox gemaakt met lpr, de printqueue. Misschien is dat queue-mechanisme iets te geavanceerd, maar toch

[Wirf]

nehru schreef op donderdag 24 november 2011 @ 23:02:
Tsja, makkelijkste is voor elk filmpje een entry in een file te zetten en een loopje maken die die file controleert, idd elke 10 seconden of zo...

Quick en dirty:

Bash:

while true
  do
    for mov in 'cat file'
      do
        convertcommando $mov
        cat file | grep -v $mov > file2
        mv file2 file
    done
  mov=""
  sleep 10
done

Ik weet dat dit even quick and dirty was; maar als je het op deze manier doet, kun je wel input vanuit je PHP script missen.
Als het PHP script namelijk een record toevoegd aan "file" op hetzelfde moment dat "cat file | grep -v $mov > file2; mv file2 file" uitgevoerd wordt, dan zal dat record verdwijnen (en dat bestand dus nooit geconverteerd worden)

Een manier om dat op te lossen, is door alle te verwerken bestanden in 1 directory te zetten, en op het moment dat de verwerking klaar is, verplaats je ze naar een andere directory.

Zoiets:

Bash:

while true; do
  FILE=`ls -tr "$DIR" | head -n 1`
  convertcommando "$FILE"
  mv "$FILE" "$DONEDIR" #of gewoon stomweg verwijderen.
done