[php] Cache maken op basis van tijd cachefile

[Gerwin]

Ik wil met onderstaand PHP-script een pagina cachen in een bestandje, ik heb een map aangemaakt waar alle cache, bestandjes in opgeslagen worden. Het is in dit voorbeeld de bedoeling dat als de datum van het cache bestandje ouder is dan 10 seconden, het scripje op FALSE springt en er dus een nieuw bestandje aangemaakt moet worden. Probleem waar ik nu mee zit is dat er ten alle tijde door de server een nieuw bestandje aangemaakt word. Iemand enig idee hoe zoiets kan?

PHP:

$age = 10;
$filename = "cache/file.cache";

if (file_exists($filename)) {
    $mtime = filemtime($filename);
    $fileage = time() - $mtime;
    if ($fileage > $age) {
        // cache gebruiken
        $usedfile = "true";
    } else {
        // nieuw maken
        $usedfile = "false";
    }
} else {
    // nieuw maken
    $usedfile = "false";
} 


// en het bestandje maken als dat nodig is

if ($usedfile = "false") { 
                ob_start();
                echo "BLAAAAAAT";
    $output = ob_get_clean();
                ob_end_clean();
    $file = fopen( $filename, 'w' ); 
    fputs($file, $output);
    fclose($file);
}

[ Voor 8% gewijzigd door Gerwin op 04-09-2004 15:46 ]

[darkrain]

Regel 7: > moet zijn < volgens mij.

Nu zeg je dat als de fileage groter is dan de age dan moet ie de cache gebruiken.
Je moet hebben dat de fileage kleiner is dan de age.

Voorbeeldje: fileage = 9 en age = 10, cache pakken.
fileage = 11 en age = 10, nieuw bestandje.

[ Voor 95% gewijzigd door darkrain op 04-09-2004 15:58 ]

[Verwijderd]

if ($usedfile = "false") {
veranderen in:
if ($usedfile == "false") {

en sowieso false/true gebruiken ipv "false"/"true"

[NMe]

Verwijderd schreef op 04 september 2004 @ 19:46:
if ($usedfile = "false") {
veranderen in:
if ($usedfile == "false") {

en sowieso false/true gebruiken ipv "false"/"true"

Sowieso wordt het dan

PHP:

if (!$usedfile) {

of

PHP:

if ($usedfile === false) {

voor de meer hardcore programmeur die ook identiteit wil zien.

_{If ($var == true) vind ik echt een ranzige constructie, is net zoiets als dit:}

PHP:

if ((12 < 13) == true)

_{Geheel overbodig dus...}

[Verwijderd]

Waarom wil je cachen op je bestandssysteem? Ik ben al een tijdje uit PHP, maar het moet toch mogelijk zijn om naast de session scope een cache te creeren in een scope die voor alle clients voor die applicatie beschikbaar zijn? Je wilt met cache zoveel mogelijk IO verkeer beperken, en serveren uit een snelle bron, geheugen.

[Sendy]

Cachen kan ook prima van je harddisk hoor. Als een lange berekening plaatsvind is die IO niet heel belangrijk.

[Gerwin]

Juist ik heb dat > al eens eerder veranderd in een < maar dit scheen niet te helpen en het probleem bleef bestaan. Eigenlijk was dit eerst een tikfoutje, maar ben uiteindelijk toch aan mezelf begonnen te twijfelen. Nadat ik nu een dubbele = heb gezet gaat het wel goed. Ik wist niet dat je bij een FALSE/TRUE waarde een dubbele gelijk-dan-teken moest gebruiken.

[Gerwin]

Verwijderd schreef op 05 september 2004 @ 00:40:
Waarom wil je cachen op je bestandssysteem? Ik ben al een tijdje uit PHP, maar het moet toch mogelijk zijn om naast de session scope een cache te creeren in een scope die voor alle clients voor die applicatie beschikbaar zijn? Je wilt met cache zoveel mogelijk IO verkeer beperken, en serveren uit een snelle bron, geheugen.

Het doel van de gehele cache is om het aantal werk van de server te beperkten. Het zijn hele zware PHP/Mysql pagina's die in topuren meer dan 10 keer per seconde word aangevraagd. Met de cache op tijd wil ik realiseren dat de pagina's toch bijvoorbeeld eens per dag/uur etc. vernieuwd worden en niet bij elk bezoek de hele pagina gegenereerd hoeft te worden. Hoewel ik er vrijwel zeker van ben dat deze methode veel sneller en wat stress van de server weghaald, ben ik toch nog een beetje aan het kijken hoe de load van de server word als hij bij elke view de datum van het bestandje moet controleren. Ik heb het vermoeden dat dergelijke checks ook door php zelf gecached worden.

[NMe]

Gerwin schreef op 05 september 2004 @ 00:57:
Juist ik heb dat > al eens eerder veranderd in een < maar dit scheen niet te helpen en het probleem bleef bestaan. Eigenlijk was dit eerst een tikfoutje, maar ben uiteindelijk toch aan mezelf begonnen te twijfelen. Nadat ik nu een dubbele = heb gezet gaat het wel goed. Ik wist niet dat je bij een FALSE/TRUE waarde een dubbele gelijk-dan-teken moest gebruiken.

Dan weet je dus niet het verschil tussen de toekennings- en de vergelijkings-operator (en de identiteitsoperator).

Toekenning: =
Vergelijking: ==
Identiteit: ===

Met de toekenningsoperator geeft je een variabele een waarde. De gehele expressie krijgt de waarde van het "getal" achter de toekenning:

PHP:

if ($getal = 4)

$getal krijgt de waarde 4, de gehele expressie krijgt de waarde 4, 4 is niet gelijk aan 0, en dus is het true -> de expressie evalueert naar true, en dus wordt de if uitgevoerd.

Met de vergelijkingsoperator wordt gekeken of een variabele een bepaalde waarde heeft:

PHP:

$getal = 3;
if ($getal == 4)

$getal is gelijk aan 3, en 3 is niet gelijk aan 4, dus evalueert de expressie naar false, wat inhoudt dat de if niet wordt uitgevoerd.

De identiteits-operator doet hetzelfde als de vergelijkingsoperator, met de toevoeging dat het ook kijkt naar het datatype:

PHP:

$getal = "3";
if ($getal === 3)

$getal heeft de waarde "3". Met de vergelijkingsoperator zou "3" gelijk zijn aan 3, maar hier niet, omdat "3" een string is, en 3 een integer. "3" is dus niet gelijk aan 3, waardoor de expressie naar false evalueert, en de if niet uitgevoerd wordt.

[Sendy]

Gerwin schreef op 05 september 2004 @ 01:03:
[...]

Het doel van de gehele cache is om het aantal werk van de server te beperkten. Het zijn hele zware PHP/Mysql pagina's die in topuren meer dan 10 keer per seconde word aangevraagd. Met de cache op tijd wil ik realiseren dat de pagina's toch bijvoorbeeld eens per dag/uur etc. vernieuwd worden en niet bij elk bezoek de hele pagina gegenereerd hoeft te worden. Hoewel ik er vrijwel zeker van ben dat deze methode veel sneller en wat stress van de server weghaald, ben ik toch nog een beetje aan het kijken hoe de load van de server word als hij bij elke view de datum van het bestandje moet controleren. Ik heb het vermoeden dat dergelijke checks ook door php zelf gecached worden.

Een goed _OS_ cachet je bestandsdatum. PHP zal dat niet doen.

Wat ik niet begrijp is dat iemand die een pagina moet verbeteren(?) niet weet dat-ie == moet gebruiken in binaire tests.

[NMe]

Overigens:

Gerwin schreef op 04 september 2004 @ 15:45:
Het is in dit voorbeeld de bedoeling dat als de datum van het cache bestandje ouder is dan 10 seconden, het scripje op FALSE springt en er dus een nieuw bestandje aangemaakt moet worden.

Ik neem aan dat dit bij wijze van voorbeeld is? Want wanneer een cache toch nooit ouder is dan 10 seconden, heeft cachen niet zoveel nut, of je site moet wel heel erg vaak bezocht worden.

[Verwijderd]

Gerwin schreef op 05 september 2004 @ 01:03:
[...]

Het doel van de gehele cache is om het aantal werk van de server te beperkten. Het zijn hele zware PHP/Mysql pagina's die in topuren meer dan 10 keer per seconde word aangevraagd. Met de cache op tijd wil ik realiseren dat de pagina's toch bijvoorbeeld eens per dag/uur etc. vernieuwd worden en niet bij elk bezoek de hele pagina gegenereerd hoeft te worden. Hoewel ik er vrijwel zeker van ben dat deze methode veel sneller en wat stress van de server weghaald, ben ik toch nog een beetje aan het kijken hoe de load van de server word als hij bij elke view de datum van het bestandje moet controleren. Ik heb het vermoeden dat dergelijke checks ook door php zelf gecached worden.

Wat Sendy aangaf is een goede mogelijkheid als je inderdaad niet met high traffic te maken krijgt. Maar als je 10 req/sec op die pagina krijgt zou ik het toch zeker overwegen om dit in geheugen te cachen.

Het is een heel simpel principe. Je maakt een structure aan op basis van bestandsnaam en query string en die cache je in die structure tezamen met een datetime stamp.

Bij een request controleer je of die combinatie in je structure voorkomt, zoja, die toon je dan. Zoniet dan wordt bij de eerste request de cache aangevuld met de pagina, en bij vervolgaanzoeken wordt de cached versie getoond.

Enige nadeel aan het hele systeem is dat bij een restart van je server je cache opnieuw moet worden opgebouwd maar dat is bij de 1ste request voor die specifieke pagina al gedaan. Elk vervolgaanzoek krijgt de cached versie tenzij je hem flushed.

[Gerwin]

Sorry dat ik dit topic nog even omhoog haal, maar nadat het zaakje nu een tijdje draaid op mijn server loop ik toch tegen een probleem op. En om voor elk iets een compleet nieuw topic aan te maken leek me een beetje overbodig.

De situatie is nu dat ik bij elke bezoeker kijk of er een cache bestandje op de server staat van de huidige pagina. Is het bestandje ouder dan de maximale tijd dan word er een nieuwe aangemaakt. Hieronder de code. Probleem is nu dat de server hij af en toe over zijn nek lijkt te gaan als de tijd verstreken is van de duur van het bestandje. Het bestandje moet vernieuwd worden bijvoorbeeld, maar in de tijd vanaf de eerste binnenkomer die het bestandje maakt lopen er een stuk of 10 misschien meer bezoekers binnen die ook een de maximale cache-tijd hebben gehad en dus ook een nieuwe cache gaan aanmaken. Dit veroorzaakt ineens een hele hoop serverload. Iemand die dit probleem ook is tegengekomen bij het cachen van pagina's? Hoe doet tweakers.net dat eigenlijk?

PHP:

$filename = ".cache/index.cache";
$age = 86400;

if (file_exists($filename)) {
    $mtime = filemtime($filename);
    $fileage = time() - $mtime;
    if ($fileage < $age) {
        $usedfile = true;
    } else { $usedfile = false;}
} else {
    $usedfile = false;
} 


if ($usedfile == false) { 

// maak de pagina en gooi deze in de cache
]

include ($filename);

[ Voor 5% gewijzigd door Gerwin op 29-09-2004 02:43 ]

[NMe]

Je zou, voordat je de file daadwerkelijk aanpast, eerst de wijzigingsdatum van het bestand kunnen aanpassen (door een spatie toe te voegen of iets dergelijks), waardoor andere instanties van je script er niet meer tegenaan kunnen lopen.

[Verwijderd]

Ik heb zelf ook zoiets gemaakt. Er kunnen PHP technisch waarschijnlijk nog wel wat verbeteringen in, maar het werkt prima.

PHP:

$realDir = "/home/dfkjsjdkfjsaklf/dksfjka/"; // Directory waarin de echte file staat.

$cacheDir  = "/home/dfkjsjdkfjsaklf/dksfjka/"; // Directory waarin de cache file komt te staan.

$cacheFileName = "text.txt"; // Naam van file

$tijd=time(); // Tijd op basis van Unix Timestamp

if (file_exists($cacheDir . $cacheFileName)) // Check of file al gecached is
{
    $cachetijd = @filemtime($cacheDir . $cacheFileName); // Cachetijd van cached file bepalen
}
else
{
    $cachetijd="0";
}

if($cachetijd+86400<$tijd) // Wanneer in dit voorbeeld 24 uur verstreken zijn zal een nieuwe pagina opgevraagd worden, anders wordt de gecachede versie gebruikt
{ 
// Opvragen van file
    $handle = @fopen ($cacheDir . $cacheFileName, r) or die ();
    $page = @fread($handle, 1000000) or die ();

// Wegschrijven in CacheDir

    $fileName = $cacheDir . $cacheFileName; 
    $filePointer = @fopen($fileName, "w"); 
    @fwrite($filePointer, $page); 
    @fclose($filePointer); 
}
else
{
    $handle = @fopen ($cacheDir . $cacheFileName, r) or die ();
    $page = @fread($handle, 1000000) or die ();

}
echo $page;

Ik hoop dat dit doet wat je wilt.

[Verwijderd]

Als je zoveel requests krijgt dan ga je toch niet van de disk cachen .. Gebruik dan het component wat je de snelste resultaten levert, je geheugen.

[Gerwin]

NMe84 schreef op 29 september 2004 @ 02:59:
Je zou, voordat je de file daadwerkelijk aanpast, eerst de wijzigingsdatum van het bestand kunnen aanpassen (door een spatie toe te voegen of iets dergelijks), waardoor andere instanties van je script er niet meer tegenaan kunnen lopen.

Dat zou een mogelijkheid kunnen zijn, maar feit blijft dan toch dat er meerdere personen de tijd aanpassen en toch in de functie terecht komen die een nieuw bestandje aanmaakt?

Verwijderd schreef op 29 september 2004 @ 10:08:
Als je zoveel requests krijgt dan ga je toch niet van de disk cachen .. Gebruik dan het component wat je de snelste resultaten levert, je geheugen.

Dat is interessant, hoe is zoiets te realiseren? Ben je voor het grootste deel van het probleem af dat er meerdere mensen een nieuw bestandje aanmaken? Tijd is toch tijd? Als je kijkt of een bestandje meer dan 100 seconden oud is bijvoorbeeld dan maakt die 100 seconden toch niet uit of het in het geheugen staat of niet? Er komen dan immers nog steeds meerdere personen op diezelfde seconde binnen...

[Verwijderd]

Zoals ik al eerder in de thread had vermeld, dat ligt eraan of de huidige versies van PHP een application wide memory scope ondersteunen. Je kunt dan een application based scope aanmaken met daarin de cache.

Dat jij last krijgt van race conditions, daar zal PHP neem ik aan, zeker met geheugen toch wel tegen bestand zijn. Een bestandssysteem is nu eenmaal anders. Zodra je gaat schrijven wordt er een lock op geplaatst totdat je klaar bent met schrijven. Dat het bestand gedurende die lock niet beschikbaar is, daar moet je dus zelf iets voor maken, ik kan me uberhaupt niet voorstellen dat PHP geen enkele features heeft om race conditions bij filesystem gebruik te voorkomen.

Iets simpels als locking bijv. ?

[Sendy]

Gordijnstok, het is geen kwestie van harddisk- vs. geheugen-snelheid. Het duurt gewoon lang om uit te rekenen (en dat gaat vast in het geheugen). Trouwens zo'n file die vaak gelezen wordt staat natuurlijk gewoon in je disk-cache.

Wat je kan doen is het cache bestand in een andere file uitrekenen. Zolang deze file bestaat geef je de webgebruikers altijd de normale cache file terug. Als de nieuwe cache file niet bestaat kijk je naar de tijd of die gemaakt moet worden.

Als je berekening klaar is, verplaats je de nieuwe cache file naar de normale cache file. Al bestaande verbindinging blijven (op *nix) gewoon de oude cache file gebruiken, die nieuwe pakken dan je verse.

edit:
en TS begrijp ik nu dat je iedere 100 seconden een gebruiker laat wachten op de (lange) berekening?

[ Voor 18% gewijzigd door Sendy op 29-09-2004 21:25 ]

[Gerwin]

Sendy, bedankt voor je opmerking, aan een nieuw bestandje om die vervolgens op de plek van de oude te zetten heb ik zelf nog niet gedacht. Maar houd je dan ook niet het probleem dat er meerdere users op hetzelfde tijdstip in de functie komen die de cache schrijft?

Het probleem wat ik heb is dat er op het moment dat de cache te oud is er meerdere users aan de gang gaan met een nieuwe cache maken totdat ééntje succesvol een cache heeft weten te maken (dit duurt soms lang omdat ineens veel users veel van de server vragen). Hierdoor heeft de server het bij het maken van nieuwe cache bestanden soms heel erg moeilijk.

Ik had graag iets gezien waarmee ik op hetzelfde tijdstip snel even de eerste user door kon laten en de rest gewoon negeren. Nu je me op het idee brengt een tweede bestandje te gebruiken is het misschien wel mogelijk snel de eerste user in die seconde in een ander bestandje te laten zetten dat de eerste user al geweest is en dat de andere users ondanks de oude cache toch geen nieuwe moeten aanmaken. Of dat werkt...

Ik maak niet elke 100 seconden een nieuwe cache aan, hoewel hij wel bij elke bezoeker kijkt of er een cache is (is die er niet dan moet de cache toch nog aangemaakt worden). Maar anders word er een nieuwe cache gemaakt elke dag en van sommige stukken van de website elk uur.

[Sendy]

Als ik het juist raad heb je een probleem dat het verfrissen van de cache erg lang duurt. In de tijd dat het neemt komen alweer nieuwe mensen. Dit probleem wordt opgegelost doordat je kijkt of het nieuw te berekenen cache bestand bestaat. Als dit bestaat, dan geef je de mensen de oude cache file terug. Je maakt dus voor alle mensen die langskomen geen nieuwe cache bestand aan. Als je het nieuwe cache bestand verplaatst bestaat het niet meer op de oude plek, je kan dus i.p.v. alleen kijken naar de datum ook kijken naar of het bestand bestaat. Als het niet bestaat _e_n de tijd is verstreken, dan maak je een nieuw bestand aan. Ik hoop dat het zo duidelijk is.

Wat ik bedoelde in mijn edit de vorige keer is dit: Als de cache gemaakt wordt, en het duurt lang om die te maken, moet die specifieke gebruiker dan lang wachten? Anders moet je het maken afsplitsen van je huidige taak. Om te weten of de file klaar is om verplaatst te worden, moet je dan een soort locking-techniek gebruiken (Als de cache klaar is, verwijder je een lockfile. Als er geen lockfile is, maar wel een cache bestand, verplaats dan.)

Het is best leuk om zoiets te implementeren, succes!

edit:

Ik heb jouw post nog eens goed doorgelezen, en het idee is inderdaad goed, maar je hoeft niet per se een extra bestand te hebben.

[ Voor 6% gewijzigd door Sendy op 30-09-2004 18:26 ]

[Verwijderd]

Een andere oplossing, degene die ik gebruik bij mijn zware pagina's, is het recachen via cronjobs..
Nadeel van de standaard condeamon is dat het per minuut gaat, maar 120 ipv 100 seconde is nog wel te doen.
Lock je file wel als je gaat sijvenchr, anders lezen clients een half geschreven file of gebruik een 2e file, die je daarna moved met PHP.. op die manier gaat het eigenlijk altijd goed bij ons (tot 7 miljoen pageviews per dag)

[ Voor 3% gewijzigd door Verwijderd op 30-09-2004 21:23 . Reden: typos ]

[Verwijderd]

Om te verkomen dat de server parallel twee keer een nieuwe pagina maakt heb je mijns inzien 2 opties:

Optie 1
Een apart bestandje wat bijhoudt of de server aan het vernieuwen is:
refresh.txt
Met daarin de waarde 1 of 0.
Bij het controleren of je gecachte pagina ouder dan 10 seconden is moet je vervolgens welke waarde er in het bestand refresh.txt staat. Is deze 0, dan moet je de op 1 zetten en de nieuwe pagina tonen. Dus de pagina opnieuw opbouwen en wegschrijven. Als als de nieuwe cach klaar is verander je de waarde naar 0. Zorg er wel voor dat het bestand tijdens de wijzigingen gelock is.

Voordeel:
Alleen cachen refreshen indien nodig.
Nadeel:
Veel operaties op file niveau.

Optie 2
Een cronjob aanmaken op een *nix host, of door middel van de taakplanner bij een windows machine. Deze refresht elke 10 seconden de cach in een apart bestand en schrijft vervangt, als de pagina compleet is, de oude cach.

Voordeel:
Makkelijke constructie
Nadeel:
Elke 10 seconden wordt de pagina gefresht, waarbij er niet gegeken wordt of dit daadwerkelijk nodig is. Dit zorgt voor constante load van de server...

Succes ermee!

[Olaf van der Spek]

Verwijderd schreef op 30 september 2004 @ 21:40:
Om te verkomen dat de server parallel twee keer een nieuwe pagina maakt heb je mijns inzien 2 opties:

Wat is er met flock gebeurd?

[Skaah]

Kun je niet gewoon je cache bestandje touchen? Dit gaat heel snel.

Systeematisch:

code:

  [request]
     |
[bekijk cache]
     |
   [oud?]
  /      \
Nee       Ja
 |         |
[Serveer] [Touch]-->Het bestand heeft nu de status 'Nieuw'.
[Cache  ]  |
          [Maak nieuwe versie]
           |
     [Serveer nieuwe versie]

[Olaf van der Spek]

Skaah schreef op 30 september 2004 @ 23:28:
Kun je niet gewoon je cache bestandje touchen? Dit gaat heel snel.

Heel snel is niet snel genoeg.

[Sendy]

Olaf >
Waarom is heel snel niet snel genoeg in de context van deze topic?

Skaah >
En wat doe je als 'het bestand' de status nieuw heeft? Dan geef je iedereen het nog uit te rekenen cache bestand?

[Olaf van der Spek]

Sendy schreef op 01 oktober 2004 @ 10:44:
Olaf >
Waarom is heel snel niet snel genoeg in de context van deze topic?

Omdat het gewoon een race condition is. Het zal dus eens in de zoveel tijd fout gaan.