Comment écrire des définitions de marionnettes réutilisables?

Question

Comment écrire des définitions de marionnettes réutilisables?

Demandé el 3 de Décembre, 2012: Quand la question a-t-elle été
274 affichage: Nombre de visites la question a
2 Réponses: Nombre de réponses aux questions
Résolu: Situation réelle de la question

Je voudrais écrire un manifeste de marionnette pour installer et configurer une application sur des serveurs cibles.

Des parties de ce manifeste doivent être réutilisables. Ainsi, j'ai utilisé define pour définir ma fonctionnalité réutilisable. En le faisant, j'ai toujours le problème que certaines parties de la définition ne sont pas réutilisables.

Un exemple simple est un ensemble de fichiers de configuration à créer. Ces fichiers doivent être placés dans le même répertoire. Ce répertoire doit être créé une seule fois.

Exemple :

nodes.pp

nœud 'monNœud.dans.undomaine' {
  mymodule::addconfig {'configfile1.xml':
    param => 'valeurquelconque',
  }
  mymodule::addconfig {'configfile2.xml':
    param => 'uneautrevaleur',
  }
}

mymodule.pp

définir mymodule::addconfig ($param) {

  $config_dir = "/le/répertoire/"

  #assurer que le répertoire existe :
  file { $config_dir:
    assurer  => répertoire,
  }

  #créer le fichier de configuration :     
  file { $name:
    chemin    => "${config_dir}/${name}"
    contenu => modèle('a_template.erb'),
    nécessite => Fichier[$config_dir],
  }
}

Cet exemple va échouer, car la ressource fichier {$config_dir: est définie deux fois maintenant.

D'après ce que j'ai compris, il est nécessaire d'extraire ces parties dans une classe. Ensuite, cela ressemble à ceci :

nodes.pp

nœud 'monNœud.dans.undomaine' {

  class { 'mymodule::createConfigurationDirectory':
  }

  mymodule::addconfig {'configfile1.xml':
    param => 'valeurquelconque',
    nécessite => Classe ['mymodule::createConfigurationDirectory'],
  }
  mymodule::addconfig {'configfile2.xml':
    param => 'uneautrevaleur',
    nécessite => Classe ['mymodule::createConfigurationDirectory'],
  }
}

Mais cela rend mon interface difficile à utiliser. Chaque utilisateur de mon module doit savoir qu'il y a une classe qui est en plus requise. Pour ce cas d'utilisation simple, la classe supplémentaire peut être acceptable. Mais avec la complexité croissante du module (beaucoup de définitions), j'ai un peu peur de perturber l'utilisateur des modules.

Donc, j'aimerais savoir s'il existe une meilleure façon de gérer ces dépendances. Idéalement, des classes comme createConfigurationDirectory sont cachées de l'utilisateur de l'API des modules.

Ou existe-t-il d'autres "Meilleures pratiques"/modèles pour gérer de telles dépendances ?

Demandé el 3 de Décembre, 2012 par Randolf Richardson

Answer 1

2 Réponses

Answer 2

2voto

Nate Points 8984

Divisez toutes les fonctionnalités en fichiers séparés dans le module, chaque fichier contenant une classe ou un type défini. Utilisez l'ordonnancement des ressources pour gérer les ressources dans le bon ordre.

Dans votre définition de nœud :

class {'mymodule':
  conffile => 'nom_fichier',
}

Dans le répertoire du manifeste de votre module :

init.pp :

# Cette classe effectue une configuration de base,
# et vous permet éventuellement de définir un fichier de configuration
class mymodule ( $conffile = undef ) {
  include mymodule::confdir

  if $conffile {
    mymodule::conffile { $conffile: }
  }
}

params.pp :

# Cette classe définit des variables
class mymodule::params {
  $confdir = '/chemin/vers/dossier'
}

confdir.pp :

# Cette classe crée un dossier de configuration
class mymodule::confdir {
  include mymodule::params

  file { $mymodule::params::confdir:
    ensure = directory,
  }
}

conffile.pp :

# Ce défini crée un fichier de configuration
define mymodule::conffile($file=$title) {
  include mymodule::params

  file { "${mymodule::params::confdir}/${file}":
    ensure  => present,
    require => Class['mymodule::confdir'],
  }
}

Répondu el 4 de Décembre, 2012 par Nate (8984 Points )

Answer 3

1voto

silviud Points 2667

Il est préférable de retirer le répertoire de configuration de la définition. Ceci est un exemple

class def($config_dir) {
    file { $config_dir:
        assurez => répertoire
     }   
}

définir def::template($file_location) {
     fichier { $file_location:
         chemin    => "${def::config_dir}/${file_location}",
         contenu => 'salut',
         requis => Classe['def'],
     }   
 }
si $fqdn == 'mon_hôte' {
    classe { 'def':
            config_dir => '/tmp/d1'
        }   
    def::template { 'f1.txt':
        file_location => "f1.txt"
    }   
    def::template { 'f2.txt':
        file_location => "f2.txt"
    }   
}

ls  /tmp/d1/
f1.txt  f2.txt

Répondu el 4 de Décembre, 2012 par silviud (2667 Points )

Comment écrire des définitions de marionnettes réutilisables?

Réponses

Questions en vedette

Top Tags

SistemesEz.com

Powered by:

Comment écrire des définitions de marionnettes réutilisables?

Réponses

Questions en vedette

Top Tags

Dans notre réseau

SistemesEz.com

Powered by: