I file temporanei devono essere salvati in / tmp o nella directory di lavoro corrente?

Ho un programma che deve generare file temporanei. È scritto per macchine a grappolo.

Se ho salvato quei file in una directory temporanea a livello di sistema (ad esempio:) /tmp, alcuni utenti si sono lamentati del fallimento del programma perché non avevano un accesso adeguato a / tmp. Ma se salvassi quei file nella directory di lavoro, quegli utenti si lamentavano anche di non voler vedere quei file misteriosi.

Quale è una pratica migliore? Devo insistere sul fatto che il salvataggio /tmpè l'approccio giusto e difendere qualsiasi errore come "funzionante come previsto" (es. Chiedere al proprio amministratore l'autorizzazione / accesso corretti)?

I file temporanei devono essere archiviati nella directory temporanea del sistema operativo per diversi motivi:

• Il sistema operativo semplifica la creazione di tali file garantendo al contempo che i loro nomi siano univoci .

• La maggior parte dei software di backup sa quali sono le directory che contengono file temporanei e le salta. Se si utilizza la directory corrente, potrebbe avere un effetto importante sulla dimensione dei backup incrementali se i backup vengono eseguiti frequentemente.

• La directory temporanea può trovarsi su un altro disco o nella RAM, rendendo l' accesso in lettura e scrittura molto, molto più veloce .

• I file temporanei vengono spesso eliminati durante il riavvio (se si trovano in un ramdisk, vengono semplicemente persi). Ciò riduce il rischio di crescita infinita se l'app non rimuove sempre correttamente i file temporanei (ad esempio dopo un arresto anomalo).

  La pulizia dei file temporanei dalla directory di lavoro potrebbe diventare facilmente disordinata se i file vengono archiviati insieme ai file dell'applicazione e dell'utente. È possibile mitigare questo problema creando una directory separata all'interno della directory corrente, ma ciò potrebbe causare un altro problema:

• La lunghezza del percorso potrebbe essere troppo lunga su alcune piattaforme. Ad esempio, su Windows, i limiti di percorso per alcune API, framework e applicazioni sono terribili , il che significa che puoi facilmente raggiungere tale limite se la directory corrente è già profonda nella gerarchia dell'albero e i nomi dei tuoi file temporanei sono troppo lunghi.

• Sui server, il monitoraggio della crescita della directory temporanea viene spesso eseguito immediatamente. Se si utilizza una directory diversa, potrebbe non essere monitorato e il monitoraggio dell'intero disco non aiuterà a capire facilmente che sono i file temporanei che occupano sempre più spazio.

Per quanto riguarda gli errori di accesso negato, assicurati di consentire al sistema operativo di creare un file temporaneo per te. Il sistema operativo può, ad esempio, sapere che per un determinato utente deve essere utilizzata una directory diversa da /tmpo C:\Windows\temp; pertanto, accedendo direttamente a queste directory, potresti effettivamente riscontrare un errore di accesso negato.

Se si ottiene un accesso negato anche quando si utilizza la chiamata del sistema operativo, significa semplicemente che la macchina è stata configurata male; questo è già stato spiegato da Blrfl . Spetta all'amministratore di sistema configurare la macchina; non è necessario modificare l'applicazione.

La creazione di file temporanei è semplice in molte lingue. Alcuni esempi:

• bash:

  # The next line will create a temporary file and return its path.
  path="$(mktemp)"
  echo "Hello, World!" > "$path"

• Pitone:

  import tempfile
  
  # Creates a file and returns a tuple containing both the handle and the path.
  handle, path = tempfile.mkstemp()
  with open(handle, "w") as f:
      f.write("Hello, World!");

• C #:

  // Creates a file and returns the path.
  var path = Path.GetTempFileName();
  File.WriteAllText(path, "Hello, World!");

• PHP:

  # Creates a file and returns the handle.
  $temp = tmpfile();
  fwrite($temp, "Hello, World!");
  fclose($temp);

• Rubino:

  require "tempfile"
  
  # Creates a file and returns the file object.
  file = Tempfile.new ""
  file << "Hello, World!"
  file.close

Si noti che in alcuni casi, come in PHP e Ruby, il file viene rimosso quando viene chiuso l'handle. Questo è un ulteriore vantaggio dell'utilizzo delle librerie in bundle con il linguaggio / framework.

Devo insistere sul fatto che il salvataggio in / tmp sia l'approccio giusto e difendere qualsiasi errore come "funzionante come previsto" (ad es. Chiedere al proprio amministratore di accedere correttamente alle autorizzazioni)?

Ci sono standard per questo e la cosa migliore che puoi fare è conformarti a loro.

POSIX, che è seguito praticamente da tutti i sistemi operativi non mainframe di qualsiasi significato che si verifichino, ha disposizioni per la creazione di file temporanei con nomi univoci in una directory utilizzando valori predefiniti che possono essere riconfigurati dall'ambiente:

• L' stdio.hintestazione C può eventualmente includere una P_tmpdirmacro che denomina la directory temporanea del sistema.
• TMPDIRè la variabile di ambiente canonica per modificare la posizione dei file temporanei. Prima di POSIX, c'erano altre variabili utilizzate, quindi tendo ad andare con la prima di quella o TMP, TEMPDIRe TEMPche ha un valore, puntando e usando l'impostazione predefinita del sistema se nessuna di queste esiste.
• Le funzioni mkstemp()e tempfile()genereranno file temporanei univoci.

Se agli utenti viene negata la possibilità di creare file temporanei, il sistema è configurato in modo errato o gli amministratori non stanno chiarendo quale sia la loro politica su tali aspetti. In questi casi, saresti su una base molto ferma nel dire che il tuo programma è conforme a uno standard di portabilità ben consolidato e che il suo comportamento può essere modificato usando le variabili di ambiente specificate dallo standard.

La directory dei file temporanei dipende fortemente dal sistema operativo / dall'ambiente. Ad esempio una directory temp-web-server è separata dalla directory os-temp per motivi di sicurezza.

Sotto ms-windows ogni utente ha la sua temp-dir.

dovresti usare createTempFile () per questo se tale funzione è disponibile.

Le risposte precedenti, sebbene corrette, non sono valide per la maggior parte dei cluster di computer.

I cluster di computer non seguono sempre le convenzioni standard per le macchine, di solito per buoni motivi, e non ha senso discuterne con gli amministratori di sistema.

La directory corrente si riferisce al file system centrale, a cui si accede attraverso la rete. Questo non è solo lento, ma carica anche il sistema per il resto degli utenti, quindi non dovresti usarlo a meno che tu non stia scrivendo molto e puoi recuperarlo se il lavoro si arresta in modo anomalo.

I nodi di calcolo hanno il proprio disco rigido, ovvero il file system più veloce disponibile e cosa dovresti usare. La documentazione del cluster dovrebbe dirti di cosa si tratta, in genere /scratch, /tmp/[jobid]o una variabile di ambiente non standard ( $SNIC_TMPin una di quelle che uso).

Quindi, ciò che raccomando è renderlo configurabile dall'utente. I valori predefiniti possono essere i primi a cui si ha accesso in scrittura a:

• $TMPDIR
• tmpfile
• /tmp
• .

Ma aspettati un basso tasso di successo con questo approccio e assicurati di emettere un grosso avviso grasso.

Modifica: aggiungerò un altro motivo per costringerlo a essere impostato dall'utente. Uno dei miei cluster è $TMPDIRimpostato su /scratch, che è scrivibile dall'utente e sul disco rigido locale. Ma la documentazione dice che tutto ciò che scrivi al di fuori di esso /scratch/[jobid]può essere eliminato in qualsiasi momento, anche durante la corsa. Quindi, se segui gli standard e ti fidi $TMPDIR, incontrerai crash casuali, molto difficili da eseguire il debug. Quindi, puoi accettare $TMPDIR, ma non fidarti.

Alcuni altri cluster hanno questa variabile correttamente configurata, quindi è possibile aggiungere un'opzione per fidarsi esplicitamente $TMPDIR, altrimenti emettere un grosso, grosso avviso.

Per molte applicazioni, dovresti considerare di inserire file temporanei in $XDG_RUNTIME_DIRo $XDG_CACHE_HOME(le altre directory XDG sono per file non temporanei). Per istruzioni su come calcolarli se non vengono passati esplicitamente nell'ambiente, vedere le specifiche basate su XDG o trovare una libreria che implementa già quella parte.

Si noti, tuttavia, che $XDG_RUNTIME_DIRè una nuova aggiunta e non esiste un fallback standard per i sistemi più vecchi a causa di problemi di sicurezza.

Se nessuno di questi è adatto, allora /tmpè il posto giusto. Non dovresti mai supporre che la directory corrente sia scrivibile.

Questo è più simile a un'alternativa, ma potresti scollegare il file () in modo non corretto dopo fopen (). Dipende dal modello di utilizzo del coraggio.

Scollegare i file, se possibile, aiuta in diversi modi:

• il file non viene visualizzato - l'utente non lo vede.
• il file non viene visualizzato da altri processi - non è possibile che altri processi modifichino il file per errore.
• facile pulizia in caso di arresto anomalo del programma.

I file devono essere creati in / tmp. Se l'utente non ha i diritti per creare il file lì, significa che il sistema non è configurato correttamente.

I file non possono essere creati nella home directory degli utenti. Molti utenti, come "nessuno", "www-data" e molti altri, non hanno il diritto di scrivere nelle loro home directory, o sono persino chroot () - ed. Si noti che anche in ambiente chroot / tmp esiste ancora.