crea ricorsivamente l'albero delle directory nel burattino senza spurgo

Question

Voglio creare la struttura di directory /var/www/apps/example/current/public se non esiste usando puppet. Se esiste già, non voglio eliminare il contenuto delle directory. Come faccio a fare questo? Qui di seguito è quello che ho finora:

file { "/var/www/apps/example/current/public": 
    owner => 'deploy', 
    group => 'users', 
    ensure => "directory", 
    purge => false, 
    recurse => true 
} 

Questo mi

Cannot create /var/www/apps/example/current/public; parent directory /var/www/apps/example/current does not exist 

Answer 1

dà Il parametro recurse non consente di creare directory superiori. Viene utilizzato per applicare valori di proprietà come owner, mode ecc. In modo ricorsivo ai contenuti delle directory e alle sottodirectory.

file { '/var/www': 
    owner => 'www-data', 
    recurse => true, 
} 

In effetti, attualmente Puppet non può creare automaticamente tutte le directory principali. Dovresti invece aggiungere tutte le directory rilevanti come risorse.

file { [ '/var/www/apps', 
     '/var/www/apps/example', 
     '/var/www/apps/example/current', 
     '/var/www/apps/example/current/public', ]: 
      ensure => directory, 
      ... 
} 

Il contenuto esistente rimane indisturbato. Non è necessario superare il parametro purge.

Answer 2

È vero che puppet non creerà directory principali per te, ma puoi creare facilmente un provider di file che faccia questo. Ad esempio, ho creato un tipo personalizzato e un provider per eseguire fondamentalmente 'mkdir -p' su sistemi POSIX: https://docs.puppetlabs.com/puppet/latest/reference/lang_namespaces.html

C'è una buona ragione, tuttavia, che Puppet non lo faccia di default. Questo perché Puppet non vuole essere responsabile delle tue autorizzazioni su più directory, dal momento che l'agente viene eseguito come root. Potrebbe essere un problema se si esegue il provisioning di/var/www o qualcosa del genere.

Il parametro file di ricusare è veramente destinata a gestire i parametri degli alberi di directory: https://docs.puppetlabs.com/references/latest/type.html#file-attribute-recurse

È possibile creare la struttura di directory e servire con la fonte => 'fantoccio: ///' uri ad esempio, impostare recurse a true, e userà tutte le modalità di file che sono impostate sulla struttura della directory che viene servita.

Answer 3

exec { "Create ${mydir}": 
    creates => $mydir, 
    command => "mkdir -p ${mydir}", 
    path => $::path 
    } -> file { $mydir : } 

L'ultima riga è così che ad altre risorse (ad esempio, file di creare all'interno $mydir) possono dipendere File[$mydir] come se fosse possibile creare con un semplice vecchio file {} blocco, which it really should.

Answer 4

Ho provato a trovare una buona soluzione ma non ci sono riuscito. Così ho capito un modo anch'io. Spero sia utile ad altre persone.

La seguente funzione genera l'elenco delle directory madri, quindi è possibile utilizzare l'elenco per creare cartelle principali. Il primo argomento è il percorso che viene utilizzato come punto di partenza per cercare le directory principali; il secondo argomento è facoltativo e viene usato come il punto finale (esclusiva) per interrompere la ricerca:

module Puppet::Parser::Functions 
    newfunction(:parentdirs, :type => :rvalue, :doc => <<-EOS 
    Build a list of all its parent directories. 
    EOS 
) do |arguments| 

    raise(Puppet::ParseError, "parentdirs(): Wrong number of arguments " + 
     "given (#{arguments.size} for 1)") if arguments.size < 1 

    $dir_until = arguments.size > 1 ? arguments[1] : nil 
    $cur = File.dirname(arguments[0]) 
    $result = [] 
    begin 
     $result.unshift($cur) 
     $last = $cur 
     $cur = File.dirname($cur) 
    end while $cur != $last and !$cur.end_with?('/') and $cur != $dir_until 

    return $result 
    end 
end 

Ecco un esempio di come usarlo:

$my_folder = '/var/www/apps/example/current/public' 
$parent_dirs = parentdirs($my_folder, '/var/www/apps') 
file { $parent_dirs: 
    ensure => 'directory', 
    owner => 'deploy', 
    group => 'users' 
} 
file { $my_folder: 
    ensure => 'directory', 
    owner => 'deploy', 
    group => 'anonymous' 
} 

I codici di cui sopra assicureranno cartelle '/var/www/apps/example 'e'/var/www/apps/example/current 'creati prima di creare'/var/www/apps/example/current/public 'mentre'/var/www/apps/example ' e sopra non rimangono toccati.

L'ho provato solo su Windows. Ma dovrebbe funzionare in ambiente Linux.

Questo non è l'ideale. Ma è meglio che elencare tutti i genitori uno per uno manualmente.

Answer 5

Se si utilizza "definire", si può avere qualcosa di simile:

mymodule::recursive_dir { "My Directory" : 
    drive => "C:", 
    path => "/path/to/folder", 
} 

Dove definisco il "definire" in mymodule.rb:

define mymodule::recursive_dir ($drive, $path) { 
    $folders = split($path, "/") 
    $folders.each |$index, $folder| { 
    $calculated_folder = inline_template("<%= @folders[0, @index + 1].join('/') %>") 
    $full_path = "${drive}${calculated_folder}" 
    if (! defined(File[$full_path]) and $full_path != $drive) { 
     file { $full_path : 
     ensure => directory, 
     } 
    } 
    } 
} 

Questo divide a parte il percorso e crea ogni directory come rimette il percorso insieme, assicurandosi di non provare a creare l'unità stessa.