Puppet Class: docker::compose

Inherits:
docker::params
Defined in:
manifests/compose.pp

Summary

install Docker Compose using the recommended curl command.

Overview

Parameters:

  • ensure (Enum[present,absent]) (defaults to: present) —

    Whether to install or remove Docker Compose Valid values are absent present

  • version (Optional[String]) (defaults to: $docker::params::compose_version) —

    The version of Docker Compose to install.

  • install_path (Optional[String]) (defaults to: $docker::params::compose_install_path) —

    The path where to install Docker Compose.

  • symlink_name (Optional[String]) (defaults to: $docker::params::compose_symlink_name) —

    The name of the symlink created pointing to the actual docker-compose binary This allows use of own docker-compose wrapper scripts for the times it’s necessary to set certain things before running the docker-compose binary

  • proxy (Optional[Pattern['^((http[s]?)?:\/\/)?([^:^@]+:[^:^@]+@|)([\da-z\.-]+)\.([\da-z\.]{2,6})(:[\d])?([\/\w \.-]*)*\/?$']]) (defaults to: undef) —

    Proxy to use for downloading Docker Compose.

  • base_url (Optional[String]) (defaults to: $docker::params::compose_base_url) —

    The base url for installation This allows use of a mirror that follows the same layout as the official repository

  • raw_url (Optional[String]) (defaults to: undef) —

    Override the raw URL for installation The default is to build a URL from baseurl. If rawurl is set, the caller is responsible for ensuring the URL points to the correct version and architecture.

  • curl_ensure (Optional[Boolean]) (defaults to: $docker::params::curl_ensure) —

    Whether or not the curl package is ensured by this module.



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
 
# File 'manifests/compose.pp', line 35

class docker::compose (
  Enum[present,absent] $ensure                 = present,
  Optional[String]               $version      = $docker::params::compose_version,
  Optional[String]               $install_path = $docker::params::compose_install_path,
  Optional[String]               $symlink_name = $docker::params::compose_symlink_name,
  Optional[Pattern['^((http[s]?)?:\/\/)?([^:^@]+:[^:^@]+@|)([\da-z\.-]+)\.([\da-z\.]{2,6})(:[\d])?([\/\w \.-]*)*\/?$']] $proxy = undef,
  Optional[String]               $base_url     = $docker::params::compose_base_url,
  Optional[String]               $raw_url      = undef,
  Optional[Boolean]              $curl_ensure  = $docker::params::curl_ensure,
) inherits docker::params {
  if $facts['os']['family'] == 'windows' {
    $file_extension = '.exe'
    $file_owner     = 'Administrator'
  } else {
    $file_extension = ''
    $file_owner     = 'root'
  }

  $docker_compose_location           = "${install_path}/${symlink_name}${file_extension}"
  $docker_compose_location_versioned = "${install_path}/docker-compose-${version}${file_extension}"

  if $ensure == 'present' {
    if $raw_url != undef {
      $docker_compose_url = $raw_url
    } else {
      $docker_compose_url = "${base_url}/${version}/docker-compose-${facts['kernel']}-${facts['os']['hardware']}${file_extension}"
    }

    if $proxy != undef {
      $proxy_opt = "--proxy ${proxy}"
    } else {
      $proxy_opt = ''
    }

    if $facts['os']['family'] == 'windows' {
      $docker_download_command = "if (Invoke-WebRequest ${docker_compose_url} ${proxy_opt} -UseBasicParsing -OutFile \"${docker_compose_location_versioned}\") { exit 0 } else { exit 1}" # lint:ignore:140chars

      exec { "Install Docker Compose ${version}":
        command  => template('docker/windows/download_docker_compose.ps1.erb'),
        provider => powershell,
        creates  => $docker_compose_location_versioned,
      }

      file { $docker_compose_location:
        ensure  => 'link',
        target  => $docker_compose_location_versioned,
        require => Exec["Install Docker Compose ${version}"],
      }
    } else {
      if $curl_ensure {
        stdlib::ensure_packages(['curl'])
      }

      exec { "Install Docker Compose ${version}":
        path    => '/usr/bin/',
        cwd     => '/tmp',
        command => "curl -s -S -L ${proxy_opt} ${docker_compose_url} -o ${docker_compose_location_versioned}",
        creates => $docker_compose_location_versioned,
        require => Package['curl'],
      }

      file { $docker_compose_location_versioned:
        owner   => $file_owner,
        mode    => '0755',
        seltype => 'container_runtime_exec_t',
        require => Exec["Install Docker Compose ${version}"],
      }

      file { $docker_compose_location:
        ensure  => 'link',
        target  => $docker_compose_location_versioned,
        require => File[$docker_compose_location_versioned],
      }
    }
  } else {
    file { $docker_compose_location_versioned:
      ensure => absent,
    }

    file { $docker_compose_location:
      ensure => absent,
    }
  }
}