What's best practice when combining Roles, Profiles, Containment and Ordering?

edit

As a general rule, you should never create direct relationships with the resources contained within a module; this violates the principles of interface driven design. You need to define and document the interfaces into your module, and create relationships with those interfaces.

The best approach, if at all possible is to design your modules so that app2 can be configured before app1. Use a simple notify relationship between the two modules. Inside App1, you would pass this notification to your service class. This side-steps the ordering problem you're experiencing.

If it is absolutely not possible to redesign the modules, the next best approach would be to modify app1 so that it has the following properties:

1. App1's service is subclassed.
2. App1's service is not contained.

I would use this general approach:

roles/manifests/usecase1.pp

class role::usecase1 {
  contain profile::app1

  Class['::app1'] ->
}

roles/manifests/usecase2.pp

class role::usecase2 {
  contain profile::app1
  contain profile::app2

  Class['::app1'] ->
  Class['::app2']
}

profiles/manifest/app1.pp

class profile::app1 {
  class { '::app1': var => 'value' }
  contain app1::
}

profiles/manifest/app2.pp

class profile::app2 {
  class { '::app2': var => 'value' }
  contain app2::

  Class['::app2'] ~>
  Class['::app1::service']

}

modules/app1/manifests/init.pp

class app1 ( $var = app1::params::var ) inherits app1::params {
  contain ::app1::install, ::app1::config

  #::app1::service is not contained in ::app1 by design.
  include ::app1::service
  Class['::app1::install'] -> Class['::app1::config'] -> Class['::app1::service'] 
}

class app1::install inherits app1 {
  package { 'app1': ensure => installed }
}

class app1::config inherits app1 {
  file { 'app1.conf': ensure => file }
}

class app1::service inherits app1 {
  #app1::service is an interface into the app1 class.
  #This class must not be renamed for compatibility purposes.
  service{ 'app1': ensure => running }
}

modules/app2/manifests/init.pp

class app2 ( $var = app2::params::var ) inherits app2::params {
  contain ::app2::install, ::app2::config, ::app2::service
  Class['::app2::install'] -> Class['::app2::config'] -> Class['::app2::service'] 
}

class app2::install inherits app2 {
  package {'app2': ensure => installed }
}

class app2::config inherits app2 {
  file {'app2.conf': ensure => file }
}

class app2::service inherits app2 {
  service{'app2': ensure => running }
}

I haven't tested this code. You may have to remove the inheritance relationship between app1 and app1::service to avoid dependencies.

Again, remember to document your code. App1 needs to clearly document its parameters, and must explain that ::app1::service is a point of entry into the module, as well as the reasons for using this approach. Again, this situation isn't ideal.

As an aside, I don't personally like the inheretence pattern. I recognize it's value in dealing with the params class. But outside that specific case, it's mostly being used to re-implement the inheritance that went away with Puppet 2.x. I realize that PuppetLabs uses this in their NTP module, but I personally prefer to make variable passing explicit rather than implicit between classes.