Puppet: Récupère le répertoire personnel des utilisateurs

Je crée un utilisateur comme suit

user { $username:
    comment => "$name",
    shell   => "$shell",
    managehome => false,
    password  => "$password",
    groups => $groups
}

Maintenant, comme vous pouvez le voir, je fais un managehome est faux Maintenant, plus tard dans la voie, je dois pousser un fichier vers le répertoire personnel de l'utilisateur.

$key = "${homedir}/${name}/file"

    file { $key:
    ensure => present,
    owner  => $username,
    group  => $username,
    mode   => 600,
    content => "$keyvalue",
    subscribe => User[$username],
}

Comment puis-je obtenir le répertoire personnel de l' utilisateur pour cela?

Hm, je pense que vous aurez besoin d'un module facter pour le faire et d'un petit fichier manifeste hacky ...

module facter: il enregistrera les variables facter pour tous les utilisateurs. comme "home_root" ou "home_apache".

require 'etc'

Etc.passwd { |user|

   Facter.add("home_#{user.name}") do
      setcode do
         user.dir
      end
   end

}

puis vous pouvez les utiliser dans votre fichier manifeste comme ceci:

$username = "root"
$home = "home_$username"
$home_path = inline_template("<%= scope.lookupvar('::$home') %>")

file { "$home_path/test.txt":
   content => "huhu",
}

Il y a peut-être une meilleure façon, mais je n'en ai pas peur.

J'ai essayé de trouver une solution pour le même problème, et il s'est avéré préférable d'adopter une approche légèrement différente.

Définissez le répertoire personnel de manière explicite, par exemple:

user { $username:
    comment    => "comment",
    home       => "/home/${username}",
    managehome => false,
    # ...
}

Quand managehomeest faux, le répertoire personnel n'est même pas créé. Vous devez donc le définir spécifiquement. Il est souvent préférable de créer une définition personnalisée pour l'ensemble de l'utilisateur:

define custom_user($username, $password) {
    user { $username:
        home     => "/home/${username}",
        password => $password,
        # etc.
    }
    file { "/home/${username}":
        ensure  => directory,
        owner   => $username,
        require => User[$username],
        # etc.
    }
}

Vous pouvez ajouter d'autres paramètres, par exemple $keyvalue, et créer un fichier de clés si ce paramètre est donné.

Vous pouvez également définir une variable globale $home = "/home"(spécifique au système d'exploitation, si nécessaire) et obtenir le répertoire d'accueil avec "${home}/${username}".

Modifier: utiliser le hachage pour définir des répertoires de départ spécifiques à l'utilisateur

Les versions plus récentes de Puppet (> = 2.6) prennent en charge les hachages. Il serait possible de définir un hachage contenant des username => /path/to/homemappages pour chaque utilisateur:

$home = {
    normal_user => '/home/normal_user',
    backup      => '/var/backup',
    mysql       => '/var/lib/mysql'
}

Pour n'importe quel nom d'utilisateur, il est alors facile d'obtenir le répertoire personnel avec $home['username'].

Hachage du répertoire personnel avec repli

La plupart du temps, il serait préférable d'avoir un "défaut de secours" si l'utilisateur n'existe pas dans le hachage. En théorie, cela est possible, bien que la syntaxe devienne un peu cryptique et gonflée:

$home = { ... }
$default_home = '/home'

user {$username:
    home => has_key($home, $username) ? {
                true => $home[$username], 
                false => "${default_home}/${username}" 
            }
    # ...
}

Cette question est ancienne, mais toujours d'actualité. Il y a en fait une meilleure façon maintenant. Ajoutez un fait personnalisé à [module] /lib/facter/home_dirs.rb contenant les éléments suivants:

require 'etc'

Facter.add(:home_dirs) do
  setcode do

    home_dirs = {}   
    Etc.passwd { |user|
      home_dirs[user.name] = user.dir
    }

    home_dirs

  end
end

Ensuite, vous pouvez accéder ainsi aux données du manifeste:

$facts['home_dirs']['some_username']

Gardez à l'esprit que cela ne fonctionne que si l'utilisateur existe déjà avant l'exécution de la marionnette. Si l'utilisateur est créé pendant l'exécution, le répertoire personnel doit être déjà connu ou au moins prévisible. La marionnette est conçue pour créer de l'ordre, après tout.

J'espère que cela aide quelqu'un.