Defining hard links in puppet

Question

Is there a way to define hardlinks inside puppet manifest?

It seems file type can only define symbolic links, but I need it to be hard links in order to make some of my chrooted applications to work. For example, I need to hardlink

/etc/hosts -> $chroot/etc/hosts
/etc/resolvf.com -> $chroot/etc/resolv.conf

and so on.

What can be the simplest way to archive that?

Update: thanks, I've ended with following defines:

define hardlinkdir(source=$name, target) {                                                                                                                   
    exec {                                                                                                                                                   
        "hardlinkdir-$name":                                                                                                                                 
            command => "cp -r --link $target $source",                                                                                                       
            path    => "/usr/bin:/bin",                                                                                                                      
            creates => $source;                                                                                                                              
    }                                                                                                                                                        
}                                                                                                                                                            

define hardlink(source=$name, target) {                                                                                                                      
    exec {                                                                                                                                                   
        "hardlink-$name":                                                                                                                                    
            command => "ln --force $target $source",                                                                                                         
            path    => "/usr/bin:/bin",                                                                                                                      
            unless  => "test $source -ef $target";                                                                                                           
    }                                                                                                                                                        
}

Sure, they are not perfect, but they does the job and it's everything I need.

Thank you for your help!

score 6 · Accepted Answer · edited Feb 07 '12 at 17:29

6

You can use also the statement "exec" if you can't find any other way.

exec { "hardlink1":
    command => "ln target source",
    path    => "/usr/local/bin:/bin",
    creates => "yourhardlink"
}

edited Feb 07 '12 at 17:29

freiheit

14,544
1
47
69

answered Feb 07 '12 at 12:52

NoNoNo

1,963
14
20

Use `creates` instead of `unless`. – Daniel C. Sobral Feb 07 '12 at 17:26
Hmm, I think unless can be better, I'll try to check if source & target are really same files. – rvs Feb 07 '12 at 17:52
@rvs `ls -i` provides the inode number of the file as the first column. Two hard links pointing at the same file on the same filesystem will have the same inode number. You could write up a module to test that. – Jeff Ferland Feb 07 '12 at 18:11
They should really support this on the `file` resource IMO. – quickshiftin Feb 19 '14 at 21:08

pcaceres · Answer 2 · 2015-12-29T19:35:26.370

works for me perfect this..

define hardlink($source=$name, $target) {                                                                                                                      
    exec {                                                                                                                                                   
        "hardlink-$name":                                                                                                                                    
            command => "ln -P --force $source $target",                                                                                                         
            path    => "/usr/bin:/bin",                                                                                                                      
            unless  => "test $source -ef $target";                                                                                                           
    }                                                                                                                                                        
}

score 1 · Answer 3 · answered May 16 '13 at 21:13

It is also fairly trivial to just pipe out the same file to multiple locations with Puppet, as an example:

  file { [ "/etc/named.conf", "/var/named/chroot/etc/named.conf" ]:
    mode    => 640,
    owner   => root,
    group   => named,
    ensure  => present,
    require => [ Package['bind'], Package['bind-chroot'], ],
    source  => "puppet:///modules/named/named.conf",
  }

Defining hard links in puppet

3 Answers3