are there iterators and loops in puppet?

When I define(?) a resource e.g. to ensure dir structure, are there any loops available?

Like that:

  for X in [app1,app2] do:
    file { '/opt/app/' + X:
      ensure => directory,
      owner  => 'root',
      group  => 'root',
      mode   => '0644',
  开发者_开发知识库  }

I have tens of directories and I am really tired with declaring it in puppet.. It would take 15 LOC of bash.

Any ideas?

---

Older versions of the puppet language have no support for loops.

But you can use an array instead of a simple string for the title and declare several resources at the same time with the same params:

$b = '/opt/app'
file { [ "$b/app1", "$b/app2" ]:
  ensure => directory,
  owner  => 'root',
  group  => 'root',
  mode   => 0644,
}

You can also declare many resources of the same type with different params by ending each resource with a ;, which is a bit more compact than repeating the file and the {s and }s:

file {
  [ "$b/app1", "$b/app2" ]:
    ensure => directory,
    owner  => 'root',
    group  => 'root',
    mode   => 0755;
  [ "$b/app1/secret", "$b/app2/secret" ]:
    ensure => directory,
    owner  => 'root',
    group  => 'root',
    mode   => 0700;
}

In the specific case of files, you can set up a source and use recursion:

file { "/opt/app":
  source => "puppet:///appsmodule/appsdir",
  recurse => true;
}

(that would require having a source of that directory structure for puppet to use as the source)

You can define a new resource type to reuse a portion of the param multiple times:

define foo {
  file {
    "/tmp/app/${title}":
      ensure => directory,
      owner  => 'root',
      mode   => 0755;
    "/tmp/otherapp/${title}":
      ensure => link,
      target => "/tmp/app/${title}",
      require => File["/tmp/app/${title}"]
  }
}

foo { ["app1", "app2", "app3", "app4"]: } 

Starting with Puppet 2.6, there's a Ruby DSL available that has all the looping functionality you could ask for: http://www.puppetlabs.com/blog/ruby-dsl/ (I've never used it, however). In Puppet 3.2, they introduced some experimental loops, however those features may change or go away in later releases.

---

As of version 3.2 there are lambdas

You must set parser = future in puppet.conf.

$a = [1,2,3]
each($a) |$value| { notice $value }

Another option for declaring multiple defined types is create_resources. Pass it a hash of hashes:

create_resources(file, {
 '/tmp/test1' => { 
      ensure => directory,
      owner  => 'root',
      group  => 'root',
      mode   => '0644',
    },  
 '/tmp/test2' => { 
      ensure => directory,
      owner  => 'www-data',
      group  => 'www-data',
      mode   => '0755',
    },  
})

---

As of Puppet 4 (and the "future parser" of late versions of Puppet 3) the Puppet DSL has iteration functions similar in form and function to some of the methods of Ruby arrays and hashes:

• each - evaluates a block of code (formally, a lambda) for each element of an array or hash
• filter - applies a lambda to each element of an array or hash and returns an array or hash of those for which the lambda evaluated to true
• map - applies a lambda to each element of an array or hash, and returns an array of the results
• reduce - applies a lambda to each element of an array or hash to build up a single result, which it returns

There is no indexed for loop along the lines of C's or Java's, but you can combine array sectioning with any of the functions above to achieve iteration over a subset of a data structure. There is no indefinite iteration along the lines of a C or Java while loop.

Of course, you can still use the resource-centric approaches described in other answers, and sometimes one of those is indeed the best available approach. You cannot any longer use Ruby DSL, however; it is removed altogether from Puppet 4. Among the iteration functions, the ability to define custom functions, the ascension of data-centric approaches into favor, and all Puppet's historic standard features, Ruby DSL seems not much missed.

---

Yes. "Ruby DSL" could help, just use file extension ".rb" instead of ".pp" in manifest and you can define puppet "type" like this:

define 'myapps::structure', :applist do
   @applist.each do |app|
       file( @name+'/'+app, 
             :ensure => directory,
             :owner  => 'root',
             :group  => 'root',
             :mode   => '0644')
   end
end

Classes and nodes also can be defined in similar way. Notice however that this feature is deprecated since release 3