open-Anweisung (gelöst) (Allgemeines zu Perl) - Perl-Community.de

Start · Board · Anwendungen/Programme/Skripte in Perl · Allgemeines zu Perl

2024-11-10 02:28:04
Europe/Berlin
Einloggen (Registrieren)
- Einstellungen
- Statistics
Jemand zu Hause?
0 Benutzer online
12 Gäste

[thread]17513[/thread]

submit to reddit

open-Anweisung [gelöst]

[gelöst]

Tags: perl5 Ähnliche Threads

Leser: 28

Articles: hide open all | hide show old branches

+23 replies
geloescht

2012-06-24 00:30
User since
2012-06-19
141 Artikel
BenutzerIn
Abend Leute

Ich habe hier einen kleinen Code-Block:
Code: (dl )

1 2 3 4 5 6 7 8 9 10 11 12 13 14

############################################# # File-Name-Generator (FNG) / Dateinamenbau # ############################################# open(FILECOUNTER, "<coresys/counter.csv"); flock(FILECOUNTER, LOCK_EX); my $oldcounter = <FILECOUNTER>; my $newcounter = $oldcounter+1; close(FILECOUNTER); open(FILECOUNTER, ">coresys/counter.csv"); flock(FILECOUNTER, LOCK_EX); print FILECOUNTER $newcounter; close(FILECOUNTER);
Hier baue ich mir eine fortlaufende Nummerierung, beginnend mit 1000 in der Datei counter.csv (Damit habe ich mir das Problem der "führenden Nullen" erspart!)

1. Erstaunlicher weise liest dieser Code die alte Nummer ein, und schreibt diese um einen Wert erhöht zurück. Ich hatte schon befürchtet, daß er alle neuen Nummern untereinander in die Datei schreibt. Was er nicht tut. Er löscht, bzw. überschreibt die alte counter-Zahl mit dem neuen Wert. Dies ist auch so von mir gewollt (Glück gehabt!)

2. Wie man im Code erkennen kann, öffnet dieser zuerst die counter.csv um den Wert bsp. 1000 auszulesen und schließt sie dann. Danach öffnet der Code die Datei erneut zum zurückschreiben des neuen Wertes (bsp.1001).

Das funktioniert im "Single"-Betrieb ganz gut. Würde aber im "Multi"-Betrieb (mehrere User) ein kleines Zeitfenster öffnen, in dem ein anderer Client die counter.csv öffnen könnte, noch bevor der neue Wert zurückgeschrieben wurde (nennt sich Race-Condition). Gibt es keine Möglichkeit, die Datei counter.csv geöffnet zu halten, um den Wert 1000 auszulesen, mit eins zu addieren und zurück zu schreiben. Und erst am Schluß der Aktion die Datei zu schliessen?

Gruß HP-User
Last edited: 2012-06-24 00:41:31 +0200 (CEST)
Past brought us "SYS 64738". Present brought us "ctrl+alt+del". But what will future bring?
- +17 replies
- topeg
  
  2012-06-24 01:31
  User since
  2006-07-10
  2611 Artikel
  BenutzerIn
  Hier zwei kommentierte Funktionen zum nutzen von geschützten Zählern:more (18.6kb)
  
  Beispielanwendung:
  
  Code (perl): (dl )
  
  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
  
  my $counter_file='counter.txt' my $cnt=read_counter($counter_file); # wenn das lesen nicht erfolgreich war # wird von read_counter "undef" in $cnt geschrieben # wenn man das testet, # kann man heraus finden, # ob das lesen erfolgreich war. # die Fehlermeldung der letzten Dateiaktion # steht in der Spezialvariable: "$!" die("Konnte Zähler nicht lesen $!\n") unless( defined ( $cnt ) ); print "COUNTER: $cnt\n"; $cnt=incement_counter($counter_file); die("Konnte Zähler nicht lesen $!\n") unless( defined ( $cnt ) ); print "COUNTER: $cnt\n";
  
  Edit: Einen Fehler im Open-Modus korrigiert es heißt "+<" und nicht "<+" das kann ich mir nie merken. :-/
  Last edited: 2012-06-24 01:47:58 +0200 (CEST)
  - +16 replies
  - geloescht
    
    2012-06-24 10:59
    User since
    2012-06-19
    141 Artikel
    BenutzerIn
    
    Hi topeg
    
    Danke für deine ausführliche Anleitung! Die wesentliche Änderung ist, daß eine Datei sowohl zum Lesen wie auch zum Schreiben geöffnet werden kann. Ich hab mir ne Liste mit den Open-Möglichkeiten ausgedruckt. Deine Variante "+<" ist die Richtige. Die andere Variante "+>" löscht den bisherigen Inhalt - was im diesem Fall contraproduktiv wäre.
    
    Hier der Code ohne Fehlerabfang (muss ich noch machen):
    
    Code: (dl )
    
    1 2 3 4 5 6 7 8 9 10 11
    
    ############################################# # File-Name-Generator (FNG) / Dateinamenbau # ############################################# open(FILECOUNTER, "+<coresys/counter.csv"); flock(FILECOUNTER, LOCK_EX); my $oldcounter = <FILECOUNTER>; my $newcounter = $oldcounter+1; seek(FILECOUNTER, 0, 0 ); print FILECOUNTER $newcounter; close(FILECOUNTER);
    
    Bei deinem Beispiel "more" öffnest, schließt, öffnest und schließt du.
    Zwischendurch könnte ein andere Client den Zählerwert auslesen und man hätte, wenn's dumm läuft, zwei Dateien mit gleicher Bezeichnung. Bei dem Code oben wird geöffnet, ausgelesen und zurückgeschrieben. Dann erst geschlossen. Und solange mit SH offen ist, kann auch kein andere was auslesen. Laut Voreinstellung müsste das Perlskript, welches von einem 2. User gestartet wird, solange warten, bis User 1 seine Aktion beendet hat.
    
    Gruß HP-User
    
    PS:Seek kannte ich in Perl noch nicht. Das man heute auf Filehandles verzichtet, bzw FH benutz wußte ich auch nicht. Trotzdem finde ich persönlich diese "alte" schreibweise von Perl schöner/übersichtlicher.
    Last edited: 2012-06-24 11:40:19 +0200 (CEST)
    Past brought us "SYS 64738". Present brought us "ctrl+alt+del". But what will future bring?
    - +15 replies
    - topeg
      
      2012-06-24 11:47
      
      User since
      2006-07-10
      2611 Artikel
      BenutzerIn
      
      Du missverstehst. Ich habe zwei Funktionen geschrieben, die jeweils Unabhängig aufgerufen werden können. Die erste Funktion Ließt den Counter nur. Die zweite ließt den alten Wert aus erhöht ihn um eins und schreibt ihn wider zurück, der geänderte Wert wird aus der Funktion zurück gegeben. Die Zweite Funktion ist eine Erweiterung der ersten. Die erste Funktion wird nicht zwingend benötigt.
      
      Du solltest auch die Größe der Datei vor dem schreiben des neuen Wertes ändern. Bedenke das nicht zwingend nur ein Zahlenwert in der Datei stehen muss, oder der neue Wert aus irgend einem Grund weniger stellen hat. Ein löschen des alten Inhaltes ist angebracht. Das macht man mit truncate
      
      Bei Linux z.B. muss ein Filehandle nicht zu dem Zeitpunkt freigeben werden, an dem Perl die Datei schließt. Darum ist es günstig vor dem Schließen der Datei diese wieder freizugeben (flock($fh, LOCK_UN);). Ansonsten könnte es zu Verzögerungen kommen.
      
      Man verzichtet nicht auf formulierte Namen für Filehandle. Aber es kommt häufig vor, das man ein Filehandle erstellt und kurz darauf wieder schließt:
      
      Code (perl): (dl )
      
      1 2 3
      
      open(my $fh, '<', $datei) or die "ERROR open $datei ($!)\n"; my @data=<$fh>; close($fh);
      
      An Stellen wie diesen ist die Konvention nützlich. Man braucht sich keinen Namen auszudenken, jeder weiß was mit "$fh" gemeint ist und dies Stelle ist schneller zu lesen.
      - +14 replies
      - geloescht
        
        2012-06-24 13:12
        
        User since
        2012-06-19
        141 Artikel
        BenutzerIn
        
        Hi topeg
        
        Zitat:'"Du solltest auch die Größe der Datei vor dem schreiben des neuen Wertes ändern. Bedenke das nicht zwingend nur ein Zahlenwert in der Datei stehen muss, oder der neue Wert aus irgend einem Grund weniger stellen hat. Ein löschen des alten Inhaltes ist angebracht. Das macht man mit truncate "'
        
        Jetzt hab ich das 3x gelesen, bis ich verstand was du mir damit sagen willst:
        
        bei einem Wert:1111
        und einem Schreibwert:22
        könnte: 2211 herauskommen? Da er nur zweistellig ist?
        
        Habe jetzt dein turncate verwendet. Geschadet hat es nicht. Das Programm läuft immer noch :-)
        
        Gruß HP-User
        Past brought us "SYS 64738". Present brought us "ctrl+alt+del". But what will future bring?
        
        +13 replies
        
        Raubtier
        
        2012-06-24 14:23
        
        User since
        2012-05-04
        1075 Artikel
        BenutzerIn
        
        2012-06-24T11:12:05 ?
        bei einem Wert:1111
        und einem Schreibwert:22
        könnte: 2211 herauskommen? Da er nur zweistellig ist?
        
        Das hast du richtig gelesen. Es könnte nicht nur herauskommen, es würde auch herauskommen!
        
        Da du in deinem Zähler aber nur natürliche Zahlen speicherst und die Darstellung für N+1 sicher mindestens genauso lang ist wie die für N, ist das bei dir irrelevant.
        
        Quote
        Trotzdem finde ich persönlich diese "alte" schreibweise von Perl schöner/übersichtlicher.
        
        Ich weiß nicht, ob du hiermit vielleicht auch das open mit $fh statt FH und 3 statt 2 Argumenten meinst. Dann liegst du falsch: die neue Schreibweise hat Vorteile: Filehandles ohne das $ sind global, was Nachteile mit sich bringt und vermieden werden sollte; die 3-Argument-Form trennt Dateinamen und Schreib-/Lesemodus und ist daher zu bevorzugen.
        
        Außerdem lässt du in deinem Code immer das ...or die weg - ich hoffe sehr, dass du dann autodie benutzt? Ansonsten merkst du nicht, wenn irgendwann das Öffnen mal nicht funktioniert.
        
        +12 replies
        
        geloescht
        
        2012-06-24 20:48
        
        User since
        2012-06-19
        141 Artikel
        BenutzerIn
        
        Hallo Raubtier
        
        Bei diesem Beispiel:
        
        Code: (dl )
        
        open(FILECOUNTER, "+<coresys/counter.csv") or die;
        
        "stirbt" das Script, wenn die Datei nicht geöffnet werden kann. Was heißt das genau:
        - es endet wenn die Datei nicht geöffnet werden kann.
        - es endet, wenn die Datei wegen EX-Block nicht geöffnet werden kann.
        - es endet, wenn die Datei wegen EX-Block nach x-Versuchen nicht geöffnet werden kann.
        
        Weiß man da was genaueres?
        
        Gruß HP-User
        Past brought us "SYS 64738". Present brought us "ctrl+alt+del". But what will future bring?
        
        +11 replies
        
        bianca
        
        2012-06-24 21:08
        
        User since
        2009-09-13
        7016 Artikel
        BenutzerIn
        
        2012-06-24T18:48:04 ?
        Weiß man da was genaueres?
        
        Was genau möchtest du wissen? Verstehe die Frage nicht.
        10 print "Hallo"
        20 goto 10
        
        +10 replies
        
        geloescht
        
        2012-06-24 21:28
        
        User since
        2012-06-19
        141 Artikel
        BenutzerIn
        
        Hallo bianca
        
        Code: (dl )
        
        1 2 3 4 5 6 7 8 9 10 11 12 13
        
        ############################################# # File-Name-Generator (FNG) / Dateinamenbau # ############################################# open(FILECOUNTER, "+<coresys/counter.csv"); flock(FILECOUNTER, LOCK_EX); my $oldcounter = <FILECOUNTER>; my $newcounter = $oldcounter+1; truncate(FILECOUNTER, 0); seek(FILECOUNTER, 0, 0); print FILECOUNTER $newcounter; close(FILECOUNTER); my $clientfile = "clientfile_".$newcounter.".csv";
        
        Wenn hier in der ersten Zeile (open) ein "or die" hinkäme, was würde es bewirken, bzw. ab wann würde das "or die" zum Tragen kommen. Doch nicht schon, wenn die zu öffnende Datei bereits durch einen anderen Vorgang geöffnet wäre? Also sprich:"Ein anderer ist grad drin und sperrt mit LOOK_EX). Das wär ja doof! *g*
        
        Gruß HP-User
        Last edited: 2012-06-24 21:30:47 +0200 (CEST)
        Past brought us "SYS 64738". Present brought us "ctrl+alt+del". But what will future bring?
        
        +9 replies
        
        FIFO
        
        2012-06-24 21:55
        
        User since
        2005-06-01
        469 Artikel
        BenutzerIn
        
        2012-06-24T19:28:20 ?
        Wenn hier in der ersten Zeile (open) ein "or die" hinkäme, was würde es bewirken, bzw. ab wann würde das "or die" zum Tragen kommen.
        
        Es ist immer sinnvoll, das Ergebnis eines open()-Aufrufs zu verwerten. Was man im Fehlerfall macht, ist einem aber selbst überlassen.
        Oft ist ein gescheitertes open() so gravierend, dass die Fortsetzung des Programms nicht sinnvoll ist. Deshalb ist der "Standard-Reflex" beim Scheitern ein die().
        Du kannst aber auch z.B. mehrere Versuche zulassen, oder mit warn() nur warnen (statt töten). Hier mal ein Beispiel (zur Verdeutlichung, nicht unbedingt als produktiver Code)
        
        Code (perl): (dl )
        
        1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
        
        my $success = 0; my $tries = 0; while ($success = open(FILECOUNTER, "+<coresys/counter.csv")) { last if $success # open hat funktioniert or ++$tries > 5; # mehr als 5 Versuche sleep(1); # warte etwas } if ($success) { flock(FILECOUNTER, LOCK_EX); my $oldcounter = <FILECOUNTER>; my $newcounter = $oldcounter+1; # etc. } else { # gib eine Warnung aus, oder mach was anderes }
        
        edit Wie rosti gerade richtig schreibt, solltest Du natürlich auch die Rückgabewerte von flock() und close() verwerten
        Last edited: 2012-06-24 21:59:20 +0200 (CEST)
        Everyone knows that debugging is twice as hard as writing a program in the first place. So if you're as clever as you can be when you write it, how will you ever debug it? -- Brian Kernighan: "The Elements of Programming Style"
        
        +8 replies
        
        geloescht
        
        2012-06-24 22:42
        
        User since
        2012-06-19
        141 Artikel
        BenutzerIn
        
        Hi FIFO
        
        Zitat:'"Es ist immer sinnvoll, das Ergebnis eines open()-Aufrufs zu verwerten. Was man im Fehlerfall macht, ist einem aber selbst überlassen.
        Oft ist ein gescheitertes open() so gravierend, dass die Fortsetzung des Programms nicht sinnvoll ist."'
        
        Hmmmm..., ich kann es jetzt in der Perldoku nicht finden, aber ist es nicht so:
        
        Bei Nutzung von flock (LOOK_EX), wird die geöffnete Datei für andere gesperrt.
        Öffnet nun ein zweites Perlscript die gleiche Datei mit flock (LOOK_EX), wartet dieses bis die benötigte Datei wieder frei ist - oder hab ich das jetzt falsch im Kopf?
        
        Ich muss nicht so oft probieren, bis eine 1 übergeben wird!?
        
        Gruß HP-User
        Past brought us "SYS 64738". Present brought us "ctrl+alt+del". But what will future bring?
        
        Gast wer
        
        2012-06-24 23:05
        
        flock kann auch fehlschlagen. ZB. könnte das BS den Befehl nicht kennen, oder Der Speicher ist voll, oder der Dateisystemtreiber ist abgestürzt. Es gibt viele Möglichkeiten wie ein Systembefehl versagen kann. Aber in den aller meisten fällen klappt es.
        
        Bei open zu prüfen ist immer sinnvoll, da es nicht selten essentiell für das Funktionieren des Programms ist und es gibt viel häufiger Probleme. Die Datei kann schreibgeschützt sein, die Zugriffsrechte können nicht stimmen, die Datei kann auch einfach nicht existieren oder wurde gelöscht, oder umbenannt. Es ist hier gar nicht so unwahrscheinlich, dass die Aktion fehlschlägt.
        Last edited: 2012-06-25 01:17:24 +0200 (CEST)
        
        +6 replies
        
        FIFO
        
        2012-06-24 23:15
        
        User since
        2005-06-01
        469 Artikel
        BenutzerIn
        
        2012-06-24T20:42:00 ?
        Bei Nutzung von flock (LOOK_EX), wird die geöffnete Datei für andere gesperrt.
        Öffnet nun ein zweites Perlscript die gleiche Datei mit flock (LOOK_EX), wartet dieses bis die benötigte Datei wieder frei ist - oder hab ich das jetzt falsch im Kopf?
        
        Das LOCK_EX verhindert das flock() durch einen anderen Prozess, das heißt in diesem Fall scheitert nicht das open(), sondern das flock() des Konkurrenzprozesses (deswegen musst Du ja den flock()-Rückgabewert prüfen, wie rosti schrieb).
        Der Code hatte mit Locking nichts zu tun, ich hatte Dich so verstanden, dass Du das die() irgendwie als Verplichtung begriffen hast.
        Everyone knows that debugging is twice as hard as writing a program in the first place. So if you're as clever as you can be when you write it, how will you ever debug it? -- Brian Kernighan: "The Elements of Programming Style"
        
        +5 replies
        
        geloescht
        
        2012-06-25 20:37
        
        User since
        2012-06-19
        141 Artikel
        BenutzerIn
        
        Abend Forum
        
        Auch auf die Gefahr hin, daß ich nerve... aber ich will das jetzt wissen *g*
        
        Code: (dl )
        
        use Fcntl ':flock';
        
        Das kommt in den Kopf des Programms und sagt dem Perl, das es in diesem Code mit "flock" zu rechnen hat (mal grob formuliert).
        
        Code: (dl )
        
        open(FILECOUNTER, "+<coresys/counter.csv");
        
        Das Öffnet eine Datei in verschiedenen Modi (nur lesen, nur schreib, lese&schreib usw.). Hier kommt der erste Verständnisfallstrick für mich:
        
        Wenn open gefordert wird, und die Datei läßt sich öffnen, gibt es keine Probleme. Wenn open gefordert wird, und die Datei ist bereits offen, was passiert dann? (Alles noch ohne flock!). Normal eine Fehlermeldung (sinngemäß: cannot open file?)
        
        Code: (dl )
        
        flock(FILECOUNTER, LOCK_EX);
        
        Das flock sagt der open-Anweisung, das sie exklusives Recht hat, und alle anderen hinten an stehen müssen?
        
        Müsste dann das flock nicht noch vor(!) der open-Anweisung stehen, wenn die Datei frei ist (Vorabprüfung), um andere Zugriffe noch vor der Öffnung zu reservieren?
        
        Also das flock macht mich noch flockig *g*
        
        Gruß HP-User
        Past brought us "SYS 64738". Present brought us "ctrl+alt+del". But what will future bring?
        
        +2 replies
        
        geloescht
        
        2012-06-25 21:28
        
        User since
        2012-06-19
        141 Artikel
        BenutzerIn
        
        So, letzter Post zum Thema open
        
        Laut dieser Quelle:
        flock-Erklärung
        
        genügt ein Abfangen der open-Anweisung nach dem Muster:
        
        Code: (dl )
        
        open(FILECOUNTER, "+<coresys/counter.csv") or die "ERROR: Unable to open the CDKG-file!";
        
        Zum flock ist zu lesen, daß ein LOCK_EX die aktuell geöffnete Datei für andere sperrt. D. h. daß ein zweiter Prozess, der ebenfalls LOCK_EX nutzt, in der Voreinstellung automatisch solange wartet, bis das erste LOCK_EX endet (z.B. durch close).
        
        Wenn das dort so richtig ist, wozu soll ich dann noch die flock auswerten?
        
        Das ist es, was ich nicht ganz begreife.
        
        Gruß HP-User
        Last edited: 2012-06-25 21:32:34 +0200 (CEST)
        Past brought us "SYS 64738". Present brought us "ctrl+alt+del". But what will future bring?
        
        rosti
        
        2012-06-25 23:13
        
        User since
        2011-03-19
        3470 Artikel
        BenutzerIn
        
        Quote
        Wenn das dort so richtig ist, wozu soll ich dann noch die flock auswerten?
        
        Es ist so richtig; und wenn Du die Rückgabe von flock() auswertest, dann weißt Du auch, ob flock() auf Deinem System funktioniert oder nicht ;)
        
        Quote
        flock() ... Returns true for success, false on failure.
        
        Also, einfach ne Warnung ausgeben und der Anwender weiß Bescheid.
        
        --Rosti
        
        FIFO
        
        2012-06-25 21:44
        
        User since
        2005-06-01
        469 Artikel
        BenutzerIn
        
        2012-06-25T18:37:09 ?
        
        Code: (dl )
        
        use Fcntl ':flock';
        
        Das kommt in den Kopf des Programms und sagt dem Perl, das es in diesem Code mit "flock" zu rechnen hat (mal grob formuliert).
        
        Nein. In Fcntl stehen (unter anderem) die Definitionen der Konstanten LOCK_SH, LOCK_EX, LOCK_NB, LOCK_UN. Wenn Du use Fcntl ':flock'; verwendest, kannst Du die Konstanten statt der entsprechenden Zahlenwerte verwenden.
        
        flock() wendest Du auf ein Datei-Handle an, der mittels open() einer Datei zugeordnet wurde.
        
        Auf eine nicht gelockte Datei können mehrere Prozesse zugreifen.
        Everyone knows that debugging is twice as hard as writing a program in the first place. So if you're as clever as you can be when you write it, how will you ever debug it? -- Brian Kernighan: "The Elements of Programming Style"
        
        Raubtier
        
        2012-06-26 00:41
        
        User since
        2012-05-04
        1075 Artikel
        BenutzerIn
        
        2012-06-25T18:37:09 ?
        Wenn open gefordert wird, und die Datei läßt sich öffnen, gibt es keine Probleme. Wenn open gefordert wird, und die Datei ist bereits offen, was passiert dann? (Alles noch ohne flock!). Normal eine Fehlermeldung (sinngemäß: cannot open file?)
        
        Probiere es doch einfach einmal aus, wenn du es wissen willst. Das hilft dir vermutlich mehr, als wenn ich dir jetzt eine Antwort geben würde!
        
        2012-06-25T18:37:09 ?
        Müsste dann das flock nicht noch vor(!) der open-Anweisung stehen, wenn die Datei frei ist (Vorabprüfung), um andere Zugriffe noch vor der Öffnung zu reservieren?
        
        Nein, weil das flock nur auf bereits geöffnete Dateien wirkt - es braucht als Parameter ja das Handle der geöffneten Datei! Daher steht es auch nach dem Öffnen.
        
        Wichtig ist auch, dass alle Programme flock verwenden müssen, damit es funktioniert. Allerdings ist das nicht hinreichend: ich habe z.B. den Fall, dass sich die zu flockende Datei auf einem Netzwerk-Dateisystem befindet - dort ist es dann so, dass das flock nur innerhalb einer bestimmten Maschine funktioniert, nicht aber für mehrere Rechner gleichzeitig. Von daher: auch wenn flock zu funktionieren scheint, ist das noch keine Garantie, dass es das auch wirklich tut.
- topeg
  
  2012-06-24 01:44
  User since
  2006-07-10
  2611 Artikel
  BenutzerIn
  Was das Problem mit den "führenden Nullen betrifft" Perl bietet eine Funktion, die das für dich übernimmt.
  
  $string=sprintf( '%04u', $counter );
  
  sprintf wandelt einen wert entsprechend einer Regel in eine Zeichenkette um. Im diesem Fall ist die Regel %04u und besagt: Ein Integerwert ohne Vorzeichen ('u'), soll in eine Zeichenkette gewandelt werden, die aus vier Zeichen besteht ('4'). Wenn der Wert kleiner ist, dann sollen die fehlenden als 0 ergänzt werden ('0'). Das "%" ist eine Markierung, um anzuzeigen das eine Zeichenformatierung folgt. Damit kann man das auch in Größeren Strings nutzen. Als Beispiel:
  $datei_name=sprintf( '/bestimmter/pfad/zu/%04u_inhalt.csv', $counter ); Dabei kommen dann Strings heraus wie:
  
  Code: (dl )
  
  1 2 3 4 5
  
  /bestimmter/pfad/zu/0001_inhalt.csv /bestimmter/pfad/zu/0002_inhalt.csv /bestimmter/pfad/zu/0003_inhalt.csv /bestimmter/pfad/zu/0010_inhalt.csv /bestimmter/pfad/zu/0142_inhalt.csv
- +3 replies
- rosti
  
  2012-06-24 21:50
  User since
  2011-03-19
  3470 Artikel
  BenutzerIn
  Hi,
  
  Race Conditions vermeidest Du, indem Du den Prozess "vom Lesen bis zum Zurückschreiben" atomar machst: Nicht mehr teilbar. D.h.:
  
  Code (perl): (dl )
  
  1 2 3 4 5 6
  
  $fh->open($file, O_RDWR) or die $!; flock $fh, LOCK_EX; # Nummer lesen # Wert erhöhen # Truncate und Zurückschreiben $fh->close; # Buffer werden geleert, Datei wird geschlossen
  
  Das ist alles: jeder Prozess, der das LOCK bekommt, hat Lesen+Schreiben für sich allein, flock() bewirkt, dass weitere Prozesse warten. Prüfe, ob flock() einen wahren Wert zurückgibt, andernfalls ist flock() nicht wirksam (Warnung ausgeben).
  
  Rosti
  - +2 replies
  - geloescht
    
    2012-06-24 23:12
    User since
    2012-06-19
    141 Artikel
    BenutzerIn
    
    Abend Leute
    
    Bevor es einem Auffällt:
    Ich will ja gerade keine Datei.. tztz... deshalb hab ich das geändert in:
    
    Code: (dl )
    
    1 2 3 4 5 6 7 8 9 10 11 12 13
    
    ############################################################ # Client-Data-Key-Generator (CDKG) / Datensatzschlüsselbau # ############################################################ open(FILECOUNTER, "+<coresys/counter.csv"); flock(FILECOUNTER, LOCK_EX); my $oldcounter = <FILECOUNTER>; my $newcounter = $oldcounter+1; truncate(FILECOUNTER, 0); seek(FILECOUNTER, 0, 0); print FILECOUNTER $newcounter; close(FILECOUNTER); my $clientdatakey = "clientdatakey_".$newcounter;
    
    So muss das sein! ;-)
    Past brought us "SYS 64738". Present brought us "ctrl+alt+del". But what will future bring?
    - rosti
      
      2012-06-24 23:36
      
      User since
      2011-03-19
      3470 Artikel
      BenutzerIn
      
      Mach noch ein $fh->truncate(0); um sicherzugehen, dass die Datei auch wirklich komplett neu geschrieben wird.
      
      Und wenn Du bischen was Neues machen möchtest, lege die Zahl mit pack "N", $zahl; in die Datei. Damit hat jede Zahl eine Länge von 4 byte und Du kannst aus dem Handler mit read $fh, $buffer, 4; lesen (unpack "N", $buffer;) liefert dann wieder die Zahl.
      
      Auf diese Art und Weise kannst Du mehrere Counter in einer Datei unterbringen...
- GwenDragon
  
  2012-06-25 08:46
  
  User since
  2005-01-17
  14745 Artikel
  Admin1
  
  Eine sicheres open erreicht man auch mit sysopen.
  Beispiele:
  http://wiki.perl-community.de/Wissensbasis/PerlTut...
  http://perl-howto.de/2008/06/sicheres-offnen-von-d...
  Last edited: 2012-06-25 08:48:42 +0200 (CEST)
  die Drachin Gwen
  
  Meine Perl-Artikel · perldev – verschiedene Perl-Versionen unter Windows starten

View all threads created 2012-06-24 00:30.