No OneTemporary
Actions

Size

59 KB

Subscribers

None

View Options

	diff --git a/lib/puppet/provider/docker_stack/ruby.rb b/lib/puppet/provider/docker_stack/ruby.rb
	index 2ea08ef..e45297a 100644
	--- a/lib/puppet/provider/docker_stack/ruby.rb
	+++ b/lib/puppet/provider/docker_stack/ruby.rb
	@@ -1,89 +1,90 @@
	# frozen_string_literal: true

	require 'deep_merge'

	Puppet::Type.type(:docker_stack).provide(:ruby) do
	desc 'Support for Puppet running Docker Stacks'

	mk_resource_methods
	commands docker: 'docker'

	def exists?
	Puppet.info("Checking for stack #{name}")
	stack_services = {}
	stack_containers = []
	resource[:compose_files].each do \|file\|
	compose_file = YAML.safe_load(File.read(file), [], [], true)
	# rubocop:disable Style/StringLiterals
	containers = docker([
	'ps',
	'--format',
	"{{.Label \"com.docker.swarm.service.name\"}}-{{.Image}}",
	'--filter',
	"label=com.docker.stack.namespace=#{name}",
	]).split("\n").each do \|c\|
	c.slice!("#{name}_")
	end
	stack_containers.push(*containers)
	stack_containers.uniq!
	# rubocop:enable Style/StringLiterals
	case compose_file['version']
	when %r{^3(\.[0-7])?$}
	stack_services.merge!(compose_file['services'])
	else
	raise(Puppet::Error, "Unsupported docker compose file syntax version \"#{compose_file['version']}\"!")
	end
	end

	if stack_services.count != stack_containers.count
	return false
	end
	counts = Hash[*stack_services.each.map { \|key, array\|
	image = (array['image']) ? array['image'] : get_image(key, stack_services)
	+ image = "#{image}:latest" unless image.include?(':')
	Puppet.info("Checking for compose service #{key} #{image}")
	["#{key}-#{image}", stack_containers.count("#{key}-#{image}")]
	}.flatten]
	# No containers found for the project
	if counts.empty? \|\|
	# Containers described in the compose file are not running
	counts.any? { \|_k, v\| v.zero? }
	false
	else
	true
	end
	end

	def get_image(service_name, stack_services)
	image = stack_services[service_name]['image']
	unless image
	if stack_services[service_name]['extends']
	image = get_image(stack_services[service_name]['extends'], stack_services)
	elsif stack_services[service_name]['build']
	image = "#{name}_#{service_name}"
	end
	end
	image
	end

	def create
	Puppet.info("Running stack #{name}")
	args = ['stack', 'deploy', compose_files, name].insert(1, bundle_file).insert(4, resource[:up_args]).compact
	docker(args)
	end

	def destroy
	Puppet.info("Removing docker stack #{name}")
	rm_args = ['stack', 'rm', name]
	docker(rm_args)
	end

	def bundle_file
	return resource[:bundle_file].map { \|x\| ['-c', x] }.flatten unless resource[:bundle_file].nil?
	end

	def compose_files
	resource[:compose_files].map { \|x\| ['-c', x] }.flatten
	end

	private
	end
	diff --git a/spec/acceptance/docker_custom_source_spec.rb b/spec/acceptance/docker_custom_source_spec.rb
	index 7e655ef..6229ae8 100644
	--- a/spec/acceptance/docker_custom_source_spec.rb
	+++ b/spec/acceptance/docker_custom_source_spec.rb
	@@ -1,106 +1,106 @@
	require 'spec_helper_acceptance'

	skip = false

	if fact('osfamily') == 'windows'
	docker_args = 'docker_ee => true, docker_ee_source_location => "https://download.docker.com/components/engine/windows-server/17.06/docker-17.06.2-ee-14.zip"'
	- default_image = 'microsoft/nanoserver'
	- default_image_tag = '10.0.14393.2189'
	+ default_image = 'winamd64/hello-world'
	+ default_image_tag = 'nanoserver-sac2016'
	#The default args are set because:
	#restart => 'always' - there is no service created to manage containers
	#net => 'nat' - docker uses bridged by default when running a container. When installing docker on windows the default network is NAT.
	default_docker_run_arg = "restart => 'always', net => 'nat',"
	default_run_command = "ping 127.0.0.1 -t"
	docker_command = "\"/cygdrive/c/Program Files/Docker/docker\""
	skip = false
	elsif fact('os.name') == 'Ubuntu' && fact('os.release.full') == '14.04'
	docker_args = "version => '18.06.1~ce~3-0~ubuntu'"
	skip = true
	else
	docker_args = ''
	skip = true
	end

	describe 'the Puppet Docker module' do
	context 'with download location', :skip => skip do
	let(:pp) {"
	class { 'docker': #{docker_args} }
	"}

	it 'should run successfully' do
	apply_manifest(pp, :catch_failures => true)
	end

	it 'should run idempotently' do
	apply_manifest(pp, :catch_changes => true) unless fact('selinux') == 'true'
	end

	it 'should be start a docker process' do
	if fact('osfamily') == 'windows'
	shell('powershell Get-Process -Name dockerd') do \|r\|
	expect(r.stdout).to match(/ProcessName/)
	end
	else
	shell('ps aux \| grep docker') do \|r\|
	expect(r.stdout).to match(/dockerd -H unix:\/\/\/var\/run\/docker.sock/)
	end
	end
	end

	it 'should install a working docker client' do
	shell("#{docker_command} ps", :acceptable_exit_codes => [0] )
	end

	it 'should stop a running container and remove container' do
	pp=<<-EOS
	class { 'docker': #{docker_args} }

	docker::image { '#{default_image}':
	require => Class['docker'],
	}

	docker::run { 'container_3_6':
	image => '#{default_image}',
	command => '#{default_run_command}',
	require => Docker::Image['#{default_image}'],
	#{default_docker_run_arg}
	}
	EOS

	pp2=<<-EOS
	class { 'docker': #{docker_args} }

	docker::image { '#{default_image}':
	require => Class['docker'],
	}

	docker::run { 'container_3_6':
	ensure => 'absent',
	image => '#{default_image}',
	require => Docker::Image['#{default_image}'],
	}
	EOS

	apply_manifest(pp, :catch_failures => true)
	apply_manifest(pp, :catch_changes => true) unless fact('selinux') == 'true'

	# A sleep to give docker time to execute properly
	sleep 15

	shell("#{docker_command} ps", :acceptable_exit_codes => [0])

	apply_manifest(pp2, :catch_failures => true)
	apply_manifest(pp2, :catch_changes => true) unless fact('selinux') == 'true'

	# A sleep to give docker time to execute properly
	sleep 15

	shell("#{docker_command} inspect container-3-6", :acceptable_exit_codes => [1])
	if fact('osfamily') == 'windows'
	shell('test -f /cygdrive/c/Users/Administrator/AppData/Local/Temp/container-3-6.service', :acceptable_exit_codes => [1])
	else
	shell('test -f /etc/systemd/system/container-3-6.service', :acceptable_exit_codes => [1])
	end
	end
	end
	end
	\ No newline at end of file
	diff --git a/spec/acceptance/docker_full_spec.rb b/spec/acceptance/docker_full_spec.rb
	index 8638a9e..79f2e7b 100644
	--- a/spec/acceptance/docker_full_spec.rb
	+++ b/spec/acceptance/docker_full_spec.rb
	@@ -1,966 +1,966 @@
	require 'spec_helper_acceptance'

	if fact('kernel') == 'windows'
	docker_args = 'docker_ee => true'
	- default_image = 'microsoft/nanoserver'
	- default_image_tag = '10.0.14393.2189'
	- second_image = 'hello-world'
	- default_digest = 'sha256:204c41542c0927ac0296802e44c56b886b47e99cf8220fb49d46951bd5fc1742'
	+ default_image = 'winamd64/hello-world'
	+ default_image_tag = 'nanoserver-sac2016'
	+ default_digest = 'sha256:88f6207b9281e60dc4a91008e68b542cc7350d06985c7fc3c5132e6f6b9b3ebe'
	+ second_image = 'winamd64/hola-mundo'
	default_dockerfile = 'C:/Users/Administrator/AppData/Local/Temp/Dockerfile'
	dockerfile_test = 'C:/Windows/Dockerfile_test.txt'
	#The default args are set because:
	#restart => 'always' - there is no service created to manage containers
	#net => 'nat' - docker uses bridged by default when running a container. When installing docker on windows the default network is NAT.
	default_docker_run_arg = "restart => 'always', net => 'nat',"
	default_run_command = "ping 127.0.0.1 -t"
	docker_command = "\"/cygdrive/c/Program Files/Docker/docker\""
	default_docker_exec_lr_command = 'cmd /c "ping 127.0.0.1 -t > c:\windows\temp\test_file.txt"'
	default_docker_exec_command = 'cmd /c "echo test > c:\windows\temp\test_file.txt"'
	docker_mount_path = 'C:/Users/Administrator/AppData/Local/Temp'
	storage_driver = "windowsfilter"
	else
	if fact('os.family') == 'RedHat'
	docker_args = "repo_opt => '--enablerepo=localmirror-extras'"
	elsif fact('os.name') == 'Ubuntu' && fact('os.release.full') == '14.04'
	docker_args = "version => '18.06.1~ce~3-0~ubuntu'"
	else
	docker_args = ''
	end
	default_image = 'alpine'
	second_image = 'busybox'
	default_image_tag = '3.7'
	default_digest = 'sha256:3dcdb92d7432d56604d4545cbd324b14e647b313626d99b889d0626de158f73a'
	default_dockerfile = '/root/Dockerfile'
	dockerfile_test = "#{default_dockerfile}_test.txt"
	docker_command = "docker"
	default_docker_run_arg = ''
	default_run_command = "init"
	default_docker_exec_lr_command = '/bin/sh -c "touch /root/test_file.txt; while true; do echo hello world; sleep 1; done"'
	default_docker_exec_command = 'touch /root/test_file.txt'
	docker_mount_path = "/root"
	storage_driver = "devicemapper"
	if fact('os.family') == 'Debian' && fact('os.release.major') =~ (/14.04\|^8$/)
	storage_driver = "aufs"
	elsif fact('os.family') == 'RedHat'
	storage_driver = "devicemapper"
	else
	storage_driver = "overlay2"
	end
	end

	describe 'the Puppet Docker module' do
	context 'clean up before each test' do
	before(:each) do
	retry_on_error_matching(60, 5, /connection failure running/) do
	# Stop all container using systemd
	shell('ls -D -1 /etc/systemd/system/docker-container* \| sed \'s/\/etc\/systemd\/system\///g\' \| sed \'s/\.service//g\' \| while read container; do service $container stop; done')
	# Delete all running containers
	shell("#{docker_command} rm -f $(#{docker_command} ps -a -q) \|\| true")
	# Delete all existing images
	shell("#{docker_command} rmi -f $(#{docker_command} images -q) \|\| true")
	# Check to make sure no images are present
	shell("#{docker_command} images \| wc -l") do \|r\|
	expect(r.stdout).to match(/^0\|1$/)
	end
	# Check to make sure no running containers are present
	shell("#{docker_command} ps \| wc -l") do \|r\|
	expect(r.stdout).to match(/^0\|1$/)
	end
	end
	end


	describe 'docker class' do
	context 'without any parameters' do
	let(:pp) {"
	class { 'docker': #{docker_args} }
	"}

	it 'should run successfully' do
	apply_manifest(pp, :catch_failures => true)
	end

	it 'should run idempotently' do
	apply_manifest(pp, :catch_changes => true) unless fact('selinux') == 'true'
	end

	it 'should be start a docker process' do
	if fact('osfamily') == 'windows'
	shell('powershell Get-Process -Name dockerd') do \|r\|
	expect(r.stdout).to match(/ProcessName/)
	end
	else
	shell('ps aux \| grep docker') do \|r\|
	expect(r.stdout).to match(/dockerd -H unix:\/\/\/var\/run\/docker.sock/)
	end
	end
	end

	it 'should install a working docker client' do
	shell("#{docker_command} ps", :acceptable_exit_codes => [0] )
	end

	it 'should stop a running container and remove container' do
	pp=<<-EOS
	class { 'docker': #{docker_args} }

	docker::image { '#{default_image}':
	require => Class['docker'],
	}

	docker::run { 'container_3_6':
	image => '#{default_image}',
	command => '#{default_run_command}',
	require => Docker::Image['#{default_image}'],
	#{default_docker_run_arg}
	}
	EOS

	pp2=<<-EOS
	class { 'docker': #{docker_args} }

	docker::image { '#{default_image}':
	require => Class['docker'],
	}

	docker::run { 'container_3_6':
	ensure => 'absent',
	image => '#{default_image}',
	require => Docker::Image['#{default_image}'],
	}
	EOS

	apply_manifest(pp, :catch_failures => true)
	apply_manifest(pp, :catch_changes => true) unless fact('selinux') == 'true'

	# A sleep to give docker time to execute properly
	sleep 15

	shell("#{docker_command} ps", :acceptable_exit_codes => [0])

	apply_manifest(pp2, :catch_failures => true)
	apply_manifest(pp2, :catch_changes => true) unless fact('selinux') == 'true'

	# A sleep to give docker time to execute properly
	sleep 15

	shell("#{docker_command} inspect container-3-6", :acceptable_exit_codes => [1])
	if fact('osfamily') == 'windows'
	shell('test -f /cygdrive/c/Users/Administrator/AppData/Local/Temp/container-3-6.service', :acceptable_exit_codes => [1])
	else
	shell('test -f /etc/systemd/system/container-3-6.service', :acceptable_exit_codes => [1])
	end
	end
	end

	context 'passing a storage driver' do
	before(:all) do
	@pp=<<-EOS
	class {'docker':
	#{docker_args},
	storage_driver => "#{storage_driver}",
	}
	EOS

	apply_manifest(@pp, :catch_failures => true)
	sleep 15
	end

	it 'should result in the docker daemon being configured with the specified storage driver' do
	shell("#{docker_command} info -f \"{{ .Driver}}\"") do \|r\|
	expect(r.stdout).to match (/#{storage_driver}/)
	end
	end
	end

	context 'passing a TCP address to bind to' do
	before(:all) do
	@pp =<<-EOS
	class { 'docker':
	tcp_bind => 'tcp://127.0.0.1:4444',
	#{docker_args}
	}
	EOS
	apply_manifest(@pp, :catch_failures => true)
	# A sleep to give docker time to execute properly
	sleep 4
	end

	it 'should run idempotently' do
	apply_manifest(@pp, :catch_changes => true) unless fact('selinux') == 'true'
	end

	it 'should result in docker listening on the specified address' do
	if fact('osfamily') == 'windows'
	shell('netstat -a -b') do \|r\|
	expect(r.stdout).to match(/127.0.0.1:4444/)
	end
	else
	shell('netstat -tulpn \| grep docker') do \|r\|
	expect(r.stdout).to match(/tcp\s+0\s+0\s+127.0.0.1:4444\s+0.0.0.0\:\*\s+LISTEN\s+\d+\/docker/)
	end
	end
	end
	end

	context 'bound to a particular unix socket' do
	before(:each) do
	@pp =<<-EOS
	class { 'docker':
	socket_bind => 'unix:///var/run/docker.sock',
	#{docker_args}
	}
	EOS
	apply_manifest(@pp, :catch_failures => true)
	# A sleep to give docker time to execute properly
	sleep 4
	end

	it 'should run idempotently' do
	apply_manifest(@pp, :catch_changes => true) unless fact('selinux') == 'true'
	end

	it 'should show docker listening on the specified unix socket' do
	if fact('osfamily') != 'windows'
	shell('ps aux \| grep docker') do \|r\|
	expect(r.stdout).to match(/unix:\/\/\/var\/run\/docker.sock/)
	end
	end
	end
	end

	context 'uninstall docker' do
	after(:all) do
	@pp =<<-EOS
	class {'docker': #{docker_args},
	ensure => 'present'
	}
	EOS
	apply_manifest(@pp, :catch_failures => true)

	# Wait for reboot if windows
	sleep 300 if fact('osfamily') == 'windows'
	end

	it 'should uninstall successfully' do
	@pp =<<-EOS
	class {'docker': #{docker_args},
	ensure => 'absent'
	}
	EOS
	apply_manifest(@pp, :catch_failures => true)
	sleep 4
	shell('docker ps', :acceptable_exit_codes => [1, 127])
	end
	end
	end

	describe 'docker::image' do

	it 'should successfully download an image from the Docker Hub' do
	pp=<<-EOS
	class { 'docker': #{docker_args} }
	docker::image { '#{default_image}':
	ensure => present,
	require => Class['docker'],
	}
	EOS
	apply_manifest(pp, :catch_failures => true)
	apply_manifest(pp, :catch_changes => true) unless fact('selinux') == 'true'

	# A sleep to give docker time to execute properly
	sleep 4

	shell("#{docker_command} images") do \|r\|
	expect(r.stdout).to match(/#{default_image}/)
	end
	end

	it 'should successfully download an image based on a tag from the Docker Hub' do
	pp=<<-EOS
	class { 'docker': #{docker_args} }
	docker::image { '#{default_image}':
	ensure => present,
	image_tag => '#{default_image_tag}',
	require => Class['docker'],
	}
	EOS

	apply_manifest(pp, :catch_failures => true)
	apply_manifest(pp, :catch_changes => true) unless fact('selinux') == 'true'

	# A sleep to give docker time to execute properly
	sleep 4

	shell("#{docker_command} images") do \|r\|
	expect(r.stdout).to match(/#{default_image}\s+#{default_image_tag}/)
	end
	end

	it 'should successfully download an image based on a digest from the Docker Hub' do
	pp=<<-EOS
	class { 'docker': #{docker_args} }
	docker::image { '#{default_image}':
	ensure => present,
	image_digest => '#{default_digest}',
	require => Class['docker'],
	}
	EOS
	apply_manifest(pp, :catch_failures => true)
	apply_manifest(pp, :catch_changes => true) unless fact('selinux') == 'true'

	# A sleep to give docker time to execute properly
	sleep 4

	shell("#{docker_command} images --digests") do \|r\|
	expect(r.stdout).to match(/#{default_image}.*#{default_digest}/)
	end
	end

	it 'should create a new image based on a Dockerfile' do

	if fact('osfamily') == 'windows'
	run_cmd = 'RUN echo test > C:\\Windows\\Temp\\Dockerfile_test.txt'
	else
	run_cmd = "RUN echo test > #{dockerfile_test}"
	end

	pp=<<-EOS
	class { 'docker': #{docker_args} }

	docker::image { 'alpine_with_file':
	docker_file => "#{default_dockerfile}",
	require => Class['docker'],
	}

	file { '#{default_dockerfile}':
	ensure => present,
	content => "FROM #{default_image}\n#{run_cmd}",
	before => Docker::Image['alpine_with_file'],
	}
	EOS

	apply_manifest(pp, :catch_failures => true)
	apply_manifest(pp, :catch_changes => true) unless fact('selinux') == 'true'

	# A sleep to give docker time to execute properly
	sleep 4
	if fact('osfamily') == 'windows'
	shell("#{docker_command} run alpine_with_file cmd /c dir Windows\\\\Temp") do \|r\|
	expect(r.stdout).to match(/_test.txt/)
	end
	else
	shell("#{docker_command} run alpine_with_file ls #{dockerfile_test}") do \|r\|
	expect(r.stdout).to match(/#{dockerfile_test}/)
	end
	end
	end

	it 'should create a new image based on a tar', :win_broken => true do
	pp=<<-EOS
	class { 'docker': #{docker_args} }
	docker::image { '#{default_image}':
	require => Class['docker'],
	ensure => present,
	}

	docker::run { 'container_2_4':
	image => '#{default_image}',
	command => '/bin/sh -c "touch /root/test_file_for_tar_test.txt; while true; do echo hello world; sleep 1; done"',
	require => Docker::Image['alpine'],
	}
	EOS

	pp2=<<-EOS
	class { 'docker': #{docker_args} }
	docker::image { 'alpine_from_commit':
	docker_tar => "/root/rootfs.tar"
	}
	EOS

	apply_manifest(pp, :catch_failures => true)
	apply_manifest(pp, :catch_changes => true) unless fact('selinux') == 'true'

	# A sleep to give docker time to execute properly
	sleep 4

	# Commit currently running container as an image
	container_id = shell("#{docker_command} ps \| awk 'FNR == 2 {print $1}'")
	shell("#{docker_command} commit #{container_id.stdout.strip} alpine_from_commit")

	# Stop all container using systemd
	shell('ls -D -1 /etc/systemd/system/docker-container* \| sed \'s/\/etc\/systemd\/system\///g\' \| sed \'s/\.service//g\' \| while read container; do service $container stop; done')

	# Stop all running containers
	shell("#{docker_command} rm -f $(docker ps -a -q) \|\| true")

	# Make sure no other containers are running
	shell("#{docker_command} ps \| wc -l") do \|r\|
	expect(r.stdout).to match(/^1$/)
	end

	# Export new to a tar file
	shell("#{docker_command} save alpine_from_commit > /root/rootfs.tar")

	# Remove all images
	shell("#{docker_command} rmi $(docker images -q) \|\| true")

	# Make sure no other images are present
	shell("#{docker_command} images \| wc -l") do \|r\|
	expect(r.stdout).to match(/^1$/)
	end

	apply_manifest(pp2, :catch_failures => true)
	apply_manifest(pp2, :catch_changes => true) unless fact('selinux') == 'true'

	# A sleep to give docker time to execute properly
	sleep 4

	shell("#{docker_command} run alpine_from_commit ls /root") do \|r\|
	expect(r.stdout).to match(/test_file_for_tar_test.txt/)
	end
	end

	it 'should successfully delete the image' do
	pp1=<<-EOS
	class { 'docker': #{docker_args} }
	docker::image { '#{default_image}':
	ensure => present,
	require => Class['docker'],
	}
	EOS
	apply_manifest(pp1, :catch_failures => true)
	pp2=<<-EOS
	class { 'docker': #{docker_args} }
	docker::image { '#{default_image}':
	ensure => absent,
	}
	EOS
	apply_manifest(pp2, :catch_failures => true)
	apply_manifest(pp2, :catch_changes => true) unless fact('selinux') == 'true'

	# A sleep to give docker time to execute properly
	sleep 4

	shell("#{docker_command} images") do \|r\|
	expect(r.stdout).to_not match(/#{default_image}/)
	end
	end
	end

	describe "docker::run" do
	it 'should start a container with a configurable command' do
	pp=<<-EOS
	class { 'docker': #{docker_args}
	}

	docker::image { '#{default_image}':
	require => Class['docker'],
	}

	docker::run { 'container_3_1':
	image => '#{default_image}',
	command => '#{default_docker_exec_lr_command}',
	require => Docker::Image['#{default_image}'],
	#{default_docker_run_arg}
	}
	EOS

	apply_manifest(pp, :catch_failures => true)
	apply_manifest(pp, :catch_changes => true) unless fact('selinux') == 'true'

	# A sleep to give docker time to execute properly
	sleep 4

	container_id = shell("#{docker_command} ps \| awk 'FNR == 2 {print $1}'")
	if fact('osfamily') == 'windows'
	shell("#{docker_command} exec #{container_id.stdout.strip} cmd /c dir Windows\\\\Temp") do \|r\|
	expect(r.stdout).to match(/test_file.txt/)
	end
	else
	shell("#{docker_command} exec #{container_id.stdout.strip} ls /root") do \|r\|
	expect(r.stdout).to match(/test_file.txt/)
	end
	end

	container_name = shell("#{docker_command} ps \| awk 'FNR == 2 {print $NF}'")
	expect("#{container_name.stdout.strip}").to match(/(container-3-1\|container_3_1)/)
	end

	it 'should start a container with port configuration' do
	pp=<<-EOS
	class { 'docker': #{docker_args}}

	docker::image { '#{default_image}':
	require => Class['docker'],
	}

	docker::run { 'container_3_2':
	image => '#{default_image}',
	command => '#{default_run_command}',
	ports => ['4444'],
	expose => ['5555'],
	require => Docker::Image['#{default_image}'],
	#{default_docker_run_arg}
	}
	EOS

	apply_manifest(pp, :catch_failures => true)
	apply_manifest(pp, :catch_changes => true) unless fact('selinux') == 'true'

	# A sleep to give docker time to execute properly
	sleep 4

	shell("#{docker_command} ps") do \|r\|
	expect(r.stdout).to match(/"#{default_run_command}".+5555\/tcp\, 0\.0\.0.0\:\d+\-\>4444\/tcp/)
	end
	end

	it 'should start a container with the hostname set' do
	pp=<<-EOS
	class { 'docker': #{docker_args} }

	docker::image { '#{default_image}':
	require => Class['docker'],
	}

	docker::run { 'container_3_3':
	image => '#{default_image}',
	command => '#{default_run_command}',
	hostname => 'testdomain.com',
	require => Docker::Image['#{default_image}'],
	#{default_docker_run_arg}
	}
	EOS

	apply_manifest(pp, :catch_failures => true)
	apply_manifest(pp, :catch_changes => true) unless fact('selinux') == 'true'

	# A sleep to give docker time to execute properly
	sleep 4

	container_id = shell("#{docker_command} ps \| awk 'FNR == 2 {print $1}'")

	shell("#{docker_command} exec #{container_id.stdout.strip} hostname") do \|r\|
	expect(r.stdout).to match(/testdomain.com/)
	end
	end

	it 'should start a container while mounting local volumes' do
	pp=<<-EOS
	class { 'docker': #{docker_args} }

	docker::image { '#{default_image}':
	require => Class['docker'],
	}

	docker::run { 'container_3_4':
	image => '#{default_image}',
	command => '#{default_run_command}',
	volumes => ["#{docker_mount_path}:#{docker_mount_path}/mnt:rw"],
	require => Docker::Image['#{default_image}'],
	#{default_docker_run_arg}
	}

	file { '#{docker_mount_path}/test_mount.txt':
	ensure => present,
	before => Docker::Run['container_3_4'],
	}
	EOS

	apply_manifest(pp, :catch_failures => true)
	apply_manifest(pp, :catch_changes => true) unless fact('selinux') == 'true'

	# A sleep to give docker time to execute properly
	sleep 4
	container_id = shell("#{docker_command} ps \| awk 'FNR == 2 {print $1}'")
	if fact('osfamily') == 'windows'
	shell("#{docker_command} exec #{container_id.stdout.strip} cmd /c dir Users\\\\Administrator\\\\AppData\\\\Local\\\\Temp\\\\mnt") do \|r\|
	expect(r.stdout).to match(/test_mount.txt/)
	end
	else
	shell("#{docker_command} exec #{container_id.stdout.strip} ls /root/mnt") do \|r\|
	expect(r.stdout).to match(/test_mount.txt/)
	end
	end
	end

	#cpuset is not supported on Docker Windows
	#STDERR: C:/Program Files/Docker/docker.exe: Error response from daemon: invalid option: Windows does not support CpusetCpus.
	it 'should start a container with cpuset paramater set', :win_broken => true do
	pp=<<-EOS
	class { 'docker': #{docker_args} }

	docker::image { '#{default_image}':
	require => Class['docker'],
	}

	docker::run { 'container_3_5_5':
	image => '#{default_image}',
	command => '#{default_run_command}',
	cpuset => ['0'],
	require => Docker::Image['#{default_image}'],
	#{default_docker_run_arg}
	}
	EOS

	apply_manifest(pp, :catch_failures => true)
	apply_manifest(pp, :catch_changes => true) unless fact('selinux') == 'true'

	# A sleep to give docker time to execute properly
	sleep 4

	shell('#{docker_command} inspect container_3_5_5') do \|r\|
	expect(r.stdout).to match(/"CpusetCpus"\: "0"/)
	end
	end

	#leagacy container linking was not implemented on Windows. --link is a legacy Docker feature: https://docs.docker.com/network/links/
	it 'should start multiple linked containers', :win_broken => true do
	pp=<<-EOS
	class { 'docker': #{docker_args} }

	docker::image { '#{default_image}':
	require => Class['docker'],
	}

	docker::run { 'container_3_5_1':
	image => '#{default_image}',
	command => '#{default_run_command}',
	require => Docker::Image['#{default_image}'],
	#{default_docker_run_arg}
	}
	EOS

	apply_manifest(pp, :catch_failures => true)
	apply_manifest(pp, :catch_changes => true) unless fact('selinux') == 'true'

	# A sleep to give docker time to execute properly
	sleep 4

	container_1 = shell("#{docker_command} ps \| awk 'FNR == 2 {print $NF}'")

	pp2=<<-EOS
	class { 'docker': #{docker_args} }

	docker::image { '#{default_image}':
	require => Class['docker'],
	}

	docker::run { 'container_3_5_2':
	image => '#{default_image}',
	command => '#{default_run_command}',
	depends => ['#{container_1.stdout.strip}'],
	links => "#{container_1.stdout.strip}:the_link",
	require => Docker::Image['#{default_image}'],
	#{default_docker_run_arg}
	}
	EOS

	apply_manifest(pp2, :catch_failures => true)
	apply_manifest(pp2, :catch_changes => true) unless fact('selinux') == 'true'

	# A sleep to give docker time to execute properly
	sleep 4

	container_2 = shell("#{docker_command} ps \| awk 'FNR == 2 {print $NF}'")

	container_id = shell("#{docker_command} ps \| awk 'FNR == 2 {print $1}'")
	shell("#{docker_command} inspect -f \"{{ .HostConfig.Links }}\" #{container_id.stdout.strip}") do \|r\|
	expect(r.stdout).to match("/#{container_1.stdout.strip}:/#{container_2.stdout.strip}/the_link")
	end
	end

	it 'should stop a running container' do
	pp=<<-EOS
	class { 'docker': #{docker_args} }

	docker::image { '#{default_image}':
	require => Class['docker'],
	}

	docker::run { 'container_3_6':
	image => '#{default_image}',
	command => '#{default_run_command}',
	require => Docker::Image['#{default_image}'],
	#{default_docker_run_arg}
	}
	EOS

	pp2=<<-EOS
	class { 'docker': #{docker_args} }

	docker::image { '#{default_image}':
	require => Class['docker'],
	}

	docker::run { 'container_3_6':
	image => '#{default_image}',
	running => false,
	require => Docker::Image['#{default_image}'],
	#{default_docker_run_arg}
	}
	EOS

	apply_manifest(pp, :catch_failures => true)
	apply_manifest(pp, :catch_changes => true) unless fact('selinux') == 'true'

	# A sleep to give docker time to execute properly
	sleep 4

	shell("#{docker_command} ps \| wc -l") do \|r\|
	expect(r.stdout).to match(/^2$/)
	end

	apply_manifest(pp2, :catch_failures => true)
	apply_manifest(pp2, :catch_changes => true) unless fact('selinux') == 'true'

	# A sleep to give docker time to execute properly
	sleep 4

	shell("#{docker_command} ps \| wc -l") do \|r\|
	expect(r.stdout).to match(/^1$/)
	end
	end

	it 'should stop a running container and remove container' do
	pp=<<-EOS
	class { 'docker': #{docker_args} }

	docker::image { '#{default_image}':
	require => Class['docker'],
	}

	docker::run { 'container_3_6_1':
	image => '#{default_image}',
	command => '#{default_run_command}',
	require => Docker::Image['#{default_image}'],
	#{default_docker_run_arg}
	}
	EOS

	pp2=<<-EOS
	class { 'docker': #{docker_args} }

	docker::image { '#{default_image}':
	require => Class['docker'],
	}

	docker::run { 'container_3_6_1':
	ensure => 'absent',
	image => '#{default_image}',
	require => Docker::Image['#{default_image}'],
	}
	EOS

	apply_manifest(pp, :catch_failures => true)
	apply_manifest(pp, :catch_changes => true) unless fact('selinux') == 'true'

	# A sleep to give docker time to execute properly
	sleep 15

	shell("#{docker_command} inspect container_3_6_1", :acceptable_exit_codes => [0])

	apply_manifest(pp2, :catch_failures => true)
	apply_manifest(pp2, :catch_changes => true) unless fact('selinux') == 'true'

	# A sleep to give docker time to execute properly
	sleep 15

	shell("#{docker_command} inspect container_3_6_1", :acceptable_exit_codes => [1])
	end

	it 'should allow dependency for ordering of independent run and image' do
	pp=<<-EOS
	class { 'docker': #{docker_args} }

	docker::image { '#{default_image}': }

	docker::run { 'container_3_7_1':
	image => '#{default_image}',
	command => '#{default_run_command}',
	#{default_docker_run_arg}
	}

	docker::image { '#{second_image}':
	require => Docker::Run['container_3_7_1'],
	}

	docker::run { 'container_3_7_2':
	image => '#{second_image}',
	command => '#{default_run_command}',
	#{default_docker_run_arg}
	}
	EOS

	apply_manifest(pp, :catch_failures => true)
	apply_manifest(pp, :catch_changes => true) unless fact('selinux') == 'true'

	end

	it 'should restart a unhealthy container' do
	pp5=<<-EOS
	class { 'docker': #{docker_args} }
	docker::run { 'container_3_7_3':
	image => '#{default_image}',
	command => '#{default_run_command}',
	health_check_cmd => 'echo',
	restart_on_unhealthy => true,
	#{default_docker_run_arg}
	}
	EOS

	pp_delete=<<-EOS
	class { 'docker': #{docker_args} }
	docker::run { 'container_3_7_3':
	image => '#{default_image}',
	ensure => absent,
	}
	EOS

	if fact('osfamily') == 'windows'
	apply_manifest(pp5, :catch_failures => true)
	elsif fact('os.release.major') =~ (/14.04\|8/)
	apply_manifest(pp5, :catch_failures => true) do \|r\|
	expect(r.stdout).to match(/container_3_7_3/)
	end
	else
	apply_manifest(pp5, :catch_failures => true) do \|r\|
	expect(r.stdout).to match(/docker-container_3_7_3-systemd-reload/)
	end
	end
	apply_manifest(pp_delete, :catch_failures => true)
	end
	end
	end

	describe "docker::exec" do
	it 'should run a command inside an already running container' do
	pp=<<-EOS
	class { 'docker': #{docker_args} }

	docker::image { '#{default_image}':
	require => Class['docker'],
	}

	docker::run { 'container_4_1':
	image => '#{default_image}',
	command => '#{default_run_command}',
	require => Docker::Image['#{default_image}'],
	#{default_docker_run_arg}
	}
	EOS

	apply_manifest(pp, :catch_failures => true)
	apply_manifest(pp, :catch_changes => true) unless fact('selinux') == 'true'

	# A sleep to give docker time to execute properly
	sleep 15

	container_1 = shell("#{docker_command} ps \| awk 'FNR == 2 {print $NF}'")

	pp2=<<-EOS
	class { 'docker': #{docker_args} }
	docker::exec { 'test_command':
	container => '#{container_1.stdout.strip}',
	command => '#{default_docker_exec_command}',
	tty => true,
	}
	EOS

	pp_delete=<<-EOS
	docker::run { 'container_4_1':
	image => '#{default_image}',
	ensure => absent,
	}
	EOS

	apply_manifest(pp2, :catch_failures => true)

	# A sleep to give docker time to execute properly
	sleep 4

	container_id = shell("#{docker_command} ps \| awk 'FNR == 2 {print $1}'")
	if fact('osfamily') == 'windows'
	shell("#{docker_command} exec #{container_id.stdout.strip} cmd /c dir Windows\\\\Temp") do \|r\|
	expect(r.stdout).to match(/test_file.txt/)
	end
	else
	shell("#{docker_command} exec #{container_id.stdout.strip} ls /root") do \|r\|
	expect(r.stdout).to match(/test_file.txt/)
	end
	end
	apply_manifest(pp_delete, :catch_failures => true)
	end

	it 'should only run if notified when refreshonly is true' do
	container_name = 'container_4_2'
	pp=<<-EOS
	class { 'docker': #{docker_args} }

	docker::image { '#{default_image}': }

	docker::run { '#{container_name}':
	image => '#{default_image}',
	command => '#{default_run_command}',
	#{default_docker_run_arg}
	}

	docker::exec { 'test_command':
	container => '#{container_name}',
	command => '#{default_docker_exec_command}',
	refreshonly => true,
	}
	EOS

	apply_manifest(pp, :catch_failures => true)
	apply_manifest(pp, :catch_changes => true) unless fact('selinux') == 'true'

	# A sleep to give docker time to execute properly
	sleep 4

	if fact('osfamily') == 'windows'
	shell("#{docker_command} exec #{container_name} cmd /c dir Windows\\\\Temp") do \|r\|
	expect(r.stdout).to_not match(/test_file.txt/)
	end
	else
	shell("#{docker_command} exec #{container_name} ls /root") do \|r\|
	expect(r.stdout).to_not match(/test_file.txt/)
	end
	end

	pp_extra=<<-EOS
	file { '#{default_dockerfile}_dummy_file':
	ensure => 'present',
	notify => Docker::Exec['test_command'],
	}
	EOS

	pp_delete=<<-EOS
	docker::run { '#{container_name}':
	image => '#{default_image}',
	ensure => absent,
	}
	EOS

	pp2 = pp + pp_extra

	apply_manifest(pp2, :catch_failures => true)
	apply_manifest(pp2, :catch_changes => true) unless fact('selinux') == 'true'

	# A sleep to give docker time to execute properly
	sleep 4

	if fact('osfamily') == 'windows'
	shell("#{docker_command} exec #{container_name} cmd /c dir Windows\\\\Temp") do \|r\|
	expect(r.stdout).to match(/test_file.txt/)
	end
	else
	shell("#{docker_command} exec #{container_name} ls /root") do \|r\|
	expect(r.stdout).to match(/test_file.txt/)
	end
	end
	apply_manifest(pp_delete, :catch_failures => true)
	end
	end
	end
	diff --git a/spec/acceptance/docker_spec.rb b/spec/acceptance/docker_spec.rb
	index 2636c7c..3b37792 100644
	--- a/spec/acceptance/docker_spec.rb
	+++ b/spec/acceptance/docker_spec.rb
	@@ -1,216 +1,213 @@
	require 'spec_helper_acceptance'

	broken = false

	registry_port = 5000

	if fact('osfamily') == 'windows'
	win_host = only_host_with_role(hosts, 'default')
	@windows_ip = win_host.ip
	docker_arg = "docker_ee => true, extra_parameters => '\"insecure-registries\": [ \"#{@windows_ip}:5000\" ]'"
	docker_registry_image = 'stefanscherer/registry-windows'
	docker_network = 'nat'
	registry_host = @windows_ip
	config_file = '/cygdrive/c/Users/Administrator/.docker/config.json'
	root_dir = "C:/Users/Administrator/AppData/Local/Temp"
	server_strip = "#{registry_host}_#{registry_port}"
	bad_server_strip = "#{registry_host}_5001"
	broken = true
	else
	if fact('osfamily') == 'RedHat'
	docker_args = "repo_opt => '--enablerepo=localmirror-extras'"
	elsif fact('os.name') == 'Ubuntu' && fact('os.release.full') == '14.04'
	docker_args = "version => '18.06.1~ce~3-0~ubuntu'"
	else
	docker_args = ''
	end
	docker_registry_image = 'registry'
	docker_network = 'bridge'
	registry_host = '127.0.0.1'
	server_strip = "#{registry_host}:#{registry_port}"
	bad_server_strip = "#{registry_host}:5001"
	config_file = '/root/.docker/config.json'
	root_dir = "/root"
	end

	describe 'docker' do
	package_name = 'docker-ce'
	service_name = 'docker'
	command = 'docker'

	context 'When adding system user', :win_broken => broken do
	let(:pp) {"
	class { 'docker': #{docker_arg}
	docker_users => ['user1']
	}
	"}

	it 'the docker daemon' do
	apply_manifest(pp, :catch_failures=>true) do \|r\|
	expect(r.stdout).to_not match(/docker-systemd-reload-before-service/)
	end
	end
	end

	context 'with default parameters', :win_broken => broken do
	let(:pp) {"
	class { 'docker':
	docker_users => [ 'testuser' ],
	#{docker_args}
	}
	docker::image { 'nginx': }
	docker::run { 'nginx':
	image => 'nginx',
	net => 'host',
	require => Docker::Image['nginx'],
	}
	docker::run { 'nginx2':
	image => 'nginx',
	restart => 'always',
	require => Docker::Image['nginx'],
	}
	"}

	it 'should apply with no errors' do
	apply_manifest(pp, :catch_failures=>true)
	end

	it 'should be idempotent' do
	apply_manifest(pp, :catch_changes=>true)
	end

	describe package(package_name) do
	it { is_expected.to be_installed }
	end

	describe service(service_name) do
	it { is_expected.to be_enabled }
	it { is_expected.to be_running }
	end

	describe command("#{command} version") do
	its(:exit_status) { should eq 0 }
	end

	describe command("#{command} images"), :sudo => true do
	its(:exit_status) { should eq 0 }
	its(:stdout) { should match /nginx/ }
	end

	describe command("#{command} inspect nginx"), :sudo => true do
	its(:exit_status) { should eq 0 }
	end

	describe command("#{command} inspect nginx2"), :sudo => true do
	its(:exit_status) { should eq 0 }
	end

	describe command("#{command} ps --no-trunc \| grep `cat /var/run/docker-nginx2.cid`"), :sudo => true do
	its(:exit_status) { should eq 0 }
	its(:stdout) { should match /nginx -g 'daemon off;'/ }
	end

	describe command('netstat -tlndp') do
	its(:exit_status) { should eq 0 }
	its(:stdout) { should match /0\.0\.0\.0\:80/ }
	end

	describe command('id testuser \| grep docker') do
	its(:exit_status) { should eq 0 }
	its(:stdout) { should match /docker/ }
	end
	end

	context "When asked to have the latest image of something", :win_broken => broken do
	let(:pp) {"
	class { 'docker':
	docker_users => [ 'testuser' ]
	}
	docker::image { 'busybox': ensure => latest }
	"}
	it 'should apply with no errors' do
	apply_manifest(pp, :catch_failures=>true)
	end
	- it 'should be idempotent' do
	- apply_manifest(pp, :catch_changes=>true)
	- end
	end

	context "When registry_mirror is set", :win_broken => broken do
	let(:pp) {"
	class { 'docker':
	registry_mirror => 'http://testmirror.io'
	}
	"}
	it 'should apply with no errors' do
	apply_manifest(pp, :catch_failures=>true)
	end

	it 'should have a registry mirror set' do
	shell('ps -aux \| grep docker') do \|r\|
	expect(r.stdout).to match(/--registry-mirror=http:\/\/testmirror.io/)
	end
	end
	end

	context 'registry' do
	before(:all) do
	@registry_address = "#{registry_host}:#{registry_port}"
	@registry_bad_address = "#{registry_host}:5001"
	# @registry_email = 'user@example.com'
	@manifest = <<-EOS
	class { 'docker': #{docker_arg}}
	docker::run { 'registry':
	image => '#{docker_registry_image}',
	pull_on_start => true,
	restart => 'always',
	net => '#{docker_network}',
	ports => '#{registry_port}:#{registry_port}',
	}
	EOS
	retry_on_error_matching(60, 5, /connection failure running/) do
	apply_manifest(@manifest, :catch_failures=>true)
	end
	# avoid a race condition with the registry taking time to start
	# on some operating systems
	sleep 10
	end

	it 'should be able to login to the registry', :retry => 3, :retry_wait => 10 do
	manifest = <<-EOS
	docker::registry { '#{@registry_address}':
	username => 'username',
	password => 'password',
	}
	EOS
	apply_manifest(manifest, :catch_failures=>true)
	shell("grep #{@registry_address} #{config_file}", :acceptable_exit_codes => [0])
	shell("test -e \"#{root_dir}/registry-auth-puppet_receipt_#{server_strip}_root\"", :acceptable_exit_codes => [0])
	end

	it 'should be able to logout from the registry' do
	manifest = <<-EOS
	docker::registry { '#{@registry_address}':
	ensure=> absent,
	}
	EOS
	apply_manifest(manifest, :catch_failures=>true)
	shell("grep #{@registry_address} #{config_file}", :acceptable_exit_codes => [1,2])
	# shell("grep #{@registry_email} #{@config_file}", :acceptable_exit_codes => [1,2])
	end

	it 'should not create receipt if registry login fails' do
	manifest = <<-EOS
	docker::registry { '#{@registry_bad_address}':
	username => 'username',
	password => 'password',
	}
	EOS
	apply_manifest(manifest, :catch_failures=>true)
	shell("grep #{@registry_bad_address} #{config_file}", :acceptable_exit_codes => [1,2])
	shell("test -e \"#{root_dir}/registry-auth-puppet_receipt_#{bad_server_strip}_root\"", :acceptable_exit_codes => [1])
	end

	end

	end
	diff --git a/spec/acceptance/stack_spec.rb b/spec/acceptance/stack_spec.rb
	index ab4c73d..10ccda1 100644
	--- a/spec/acceptance/stack_spec.rb
	+++ b/spec/acceptance/stack_spec.rb
	@@ -1,153 +1,158 @@
	require 'spec_helper_acceptance'

	if fact('osfamily') == 'windows'
	docker_args = 'docker_ee => true'
	tmp_path = 'C:/cygwin64/tmp'
	test_container = 'nanoserver-sac2016'
	wait_for_container_seconds = 120

	else
	if fact('os.name') == 'Ubuntu' && fact('os.release.full') == '14.04'
	docker_args = "version => '18.06.1~ce~3-0~ubuntu'"
	else
	docker_args = ''
	end
	tmp_path = '/tmp'
	test_container = 'alpine'
	wait_for_container_seconds = 10
	end

	describe 'docker stack' do
	before(:all) do
	retry_on_error_matching(60, 5, /connection failure running/) do
	@install_code = <<-code
	class { 'docker': #{docker_args} }
	docker::swarm {'cluster_manager':
	init => true,
	ensure => 'present',
	advertise_addr => $facts['networking']['ip'],
	listen_addr => $facts['networking']['ip'],
	require => Class['docker'],
	}
	code
	apply_manifest(@install_code, :catch_failures=>true)
	end
	end

	context 'Creating stack' do
	let(:install) {"
	docker_stack { 'web':
	compose_files => ['#{tmp_path}/docker-stack.yml'],
	ensure => present,
	}"
	}

	it 'should deploy stack' do
	apply_manifest(install, :catch_failures=>true)
	sleep wait_for_container_seconds
	end

	it 'should be idempotent' do
	apply_manifest(install, :catch_changes=>true)
	end

	it 'should find a stack' do
	shell('docker stack ls') do \|r\|
	expect(r.stdout).to match(/web/)
	end
	end

	- it 'should find a docker container' do
	- shell("docker ps \| grep web_compose_test", :acceptable_exit_codes => [0])
	- end
	+ it 'should not find a docker container' do
	+ shell("docker ps -a -q -f \"name=web_compose_test\"", :acceptable_exit_codes => [0])
	+ end
	end

	context 'Destroying stack' do
	let(:install) {"
	docker_stack { 'web':
	compose_files => ['#{tmp_path}/docker-stack.yml'],
	ensure => present,
	}"
	}
	let(:destroy) {"
	docker_stack { 'web':
	compose_files => ['#{tmp_path}/docker-stack.yml'],
	ensure => absent,
	}"
	}
	it 'should run successfully' do
	apply_manifest(destroy, :catch_failures=>true)
	sleep 10
	end

	it 'should be idempotent' do
	- apply_manifest(destroy, :catch_changes=>true)
	- sleep 5
	+ retry_on_error_matching(10, 3, /Removing network web_default/) do
	+ apply_manifest(destroy, :catch_changes=>true)
	+ end
	end

	it 'should not find a docker stack' do
	- sleep 5
	- shell('docker stack ls') do \|r\|
	- expect(r.stdout).to_not match(/web/)
	- end
	+ shell('docker stack ls') do \|r\|
	+ expect(r.stdout).to_not match(/web/)
	+ end
	end
	end

	context 'creating stack with multi compose files' do

	before(:all) do
	@install_code = <<-code
	docker_stack { 'web':
	compose_files => ['#{tmp_path}/docker-stack.yml', '#{tmp_path}/docker-stack-override.yml'],
	ensure => present,
	}
	code

	apply_manifest(@install_code, :catch_failures=>true)
	end

	it "should find container with web_compose_test tag" do
	sleep wait_for_container_seconds
	shell("docker ps \| grep web_compose_test", :acceptable_exit_codes => [0])
	end
	end

	context 'Destroying project with multiple compose files' do
	before(:all) do
	@install_code = <<-code
	docker_stack { 'web':
	compose_files => ['#{tmp_path}/docker-stack.yml', '#{tmp_path}/docker-stack-override.yml'],
	ensure => present,
	}
	code

	apply_manifest(@install_code, :catch_failures=>true)

	@destroy_code = <<-code
	docker_stack { 'web':
	compose_files => ['#{tmp_path}/docker-stack.yml', '#{tmp_path}/docker-stack-override.yml'],
	ensure => absent,
	}
	code

	- apply_manifest(@destroy_code, :catch_failures=>true)
	- sleep 10# wait for containers to stop
	+ retry_on_error_matching(10, 3, /Removing network web_default/) do
	+ apply_manifest(@destroy_code, :catch_failures=>true)
	+ end
	+ sleep 15 # Wait for containers to stop and be destroyed
	end

	it 'should be idempotent' do
	- apply_manifest(@destroy_code, :catch_changes=>true)
	- sleep 5
	+ retry_on_error_matching(10, 3, /Removing network web_default/) do
	+ apply_manifest(@destroy_code, :catch_changes=>true)
	+ end
	end

	it 'should not find a docker stack' do
	shell('docker stack ls') do \|r\|
	expect(r.stdout).to_not match(/web/)
	end
	end

	it 'should not find a docker container' do
	- shell("docker ps \| grep web_compose_test", :acceptable_exit_codes => [1])
	+ shell("docker ps", :acceptable_exit_codes => [0]) do \|r\|
	+ expect(r.stdout).not_to match(/web_compose_test/)
	+ end
	end
	end

	end
	diff --git a/spec/spec_helper_acceptance.rb b/spec/spec_helper_acceptance.rb
	index 075dc68..b98127c 100644
	--- a/spec/spec_helper_acceptance.rb
	+++ b/spec/spec_helper_acceptance.rb
	@@ -1,171 +1,171 @@
	# frozen_string_literal: true

	require 'beaker-rspec/spec_helper'
	require 'beaker-rspec/helpers/serverspec'
	require 'beaker/puppet_install_helper'
	require 'rspec/retry'

	begin
	require 'pry'
	rescue LoadError # rubocop:disable Lint/HandleExceptions for optional loading
	end

	# This method allows a block to be passed in and if an exception is raised
	# that matches the 'error_matcher' matcher, the block will wait a set number
	# of seconds before retrying.
	# Params:
	# - max_retry_count - Max number of retries
	# - retry_wait_interval_secs - Number of seconds to wait before retry
	# - error_matcher - Matcher which the exception raised must match to allow retry
	# Example Usage:
	# retry_on_error_matching(3, 5, /OpenGPG Error/) do
	# apply_manifest(pp, :catch_failures => true)
	# end
	def retry_on_error_matching(max_retry_count = 3, retry_wait_interval_secs = 5, error_matcher = nil)
	try = 0
	begin
	try += 1
	yield
	rescue StandardError => e
	raise unless try < max_retry_count && (error_matcher.nil? \|\| e.message =~ error_matcher)
	sleep retry_wait_interval_secs
	retry
	end
	end

	run_puppet_install_helper unless ENV['BEAKER_provision'] == 'no'

	RSpec.configure do \|c\|
	# Add exclusive filter for Windows untill all the windows functionality is implemented
	c.filter_run_excluding win_broken: true

	# Project root
	proj_root = File.expand_path(File.join(File.dirname(__FILE__), '..'))

	# Readable test descriptions
	c.formatter = :documentation

	# show retry status in spec process
	c.verbose_retry = true
	# show exception that triggers a retry if verbose_retry is set to true
	c.display_try_failure_messages = true

	# Configure all nodes in nodeset
	c.before :suite do
	# Install module and dependencies
	hosts.each do \|host\|
	next unless not_controller(host)
	copy_module_to(host, source: proj_root, module_name: 'docker')
	# Due to RE-6764, running yum update renders the machine unable to install
	# other software. Thus this workaround.
	if fact_on(host, 'operatingsystem') == 'RedHat'
	on(host, 'mv /etc/yum.repos.d/redhat.repo /etc/yum.repos.d/internal-mirror.repo')
	on(host, 'rpm -ivh https://dl.fedoraproject.org/pub/epel/epel-release-latest-7.noarch.rpm')
	end
	on(host, 'yum update -y -q') if fact_on(host, 'osfamily') == 'RedHat'

	on host, puppet('module', 'install', 'puppetlabs-stdlib', '--version', '4.24.0'), acceptable_exit_codes: [0, 1]
	on host, puppet('module', 'install', 'puppetlabs-apt', '--version', '4.4.1'), acceptable_exit_codes: [0, 1]
	on host, puppet('module', 'install', 'puppetlabs-translate', '--version', '1.0.0'), acceptable_exit_codes: [0, 1]
	on host, puppet('module', 'install', 'puppetlabs-powershell', '--version', '2.1.5'), acceptable_exit_codes: [0, 1]
	on host, puppet('module', 'install', 'puppetlabs-reboot', '--version', '2.0.0'), acceptable_exit_codes: [0, 1]

	# net-tools required for netstat utility being used by some tests
	if fact_on(host, 'osfamily') == 'RedHat' && fact_on(host, 'operatingsystemmajrelease') == '7'
	on(host, 'yum install -y net-tools device-mapper')
	end

	if fact_on(host, 'osfamily') == 'Debian'
	on(host, 'apt-get install net-tools')
	end
	docker_compose_content_v3 = <<-EOS
	version: "3.4"
	x-images:
	&default-image
	alpine:3.8
	services:
	compose_test:
	image: *default-image
	command: /bin/sh -c "while true; do echo hello world; sleep 1; done"
	EOS
	docker_compose_override_v3 = <<-EOS
	version: "3.4"
	x-images:
	&default-image
	debian:stable-slim
	services:
	compose_test:
	image: *default-image
	command: /bin/sh -c "while true; do echo hello world; sleep 1; done"
	EOS
	docker_stack_override_v3 = <<-EOS
	version: "3.4"
	x-images:
	&default-image
	debian:stable-slim
	services:
	compose_test:
	image: *default-image
	command: /bin/sh -c "while true; do echo hello world; sleep 1; done"
	EOS
	docker_compose_content_v3_windows = <<-EOS
	version: "3"
	services:
	compose_test:
	- image: hello-world:nanoserver
	+ image: winamd64/hello-world
	command: cmd.exe /C "ping 8.8.8.8 -t"
	networks:
	default:
	external:
	name: nat
	EOS
	docker_compose_override_v3_windows = <<-EOS
	version: "3"
	services:
	compose_test:
	- image: hello-world:nanoserver-sac2016
	+ image: winamd64/hello-world:nanoserver-sac2016
	command: cmd.exe /C "ping 8.8.8.8 -t"
	networks:
	default:
	external:
	name: nat
	EOS
	docker_stack_content_windows = <<-EOS
	version: "3"
	services:
	compose_test:
	- image: hello-world:nanoserver
	+ image: winamd64/hello-world
	command: cmd.exe /C "ping 8.8.8.8 -t"
	EOS
	docker_stack_override_windows = <<-EOS
	version: "3"
	services:
	compose_test:
	- image: hello-world:nanoserver-sac2016
	+ image: winamd64/hello-world:nanoserver-sac2016
	EOS
	if fact_on(host, 'osfamily') == 'windows'
	create_remote_file(host, '/tmp/docker-compose-v3.yml', docker_compose_content_v3_windows)
	create_remote_file(host, '/tmp/docker-stack.yml', docker_stack_content_windows)
	create_remote_file(host, '/tmp/docker-compose-override-v3.yml', docker_compose_override_v3_windows)
	create_remote_file(host, '/tmp/docker-stack-override.yml', docker_stack_override_windows)
	else
	create_remote_file(host, '/tmp/docker-compose-v3.yml', docker_compose_content_v3)
	create_remote_file(host, '/tmp/docker-stack.yml', docker_compose_content_v3)
	create_remote_file(host, '/tmp/docker-compose-override-v3.yml', docker_compose_override_v3)
	create_remote_file(host, '/tmp/docker-stack-override.yml', docker_stack_override_v3)
	end

	next unless fact_on(host, 'osfamily') == 'windows'
	win_host = only_host_with_role(hosts, 'default')
	retry_on_error_matching(60, 5, %r{connection failure running}) do
	@windows_ip = win_host.ip
	end
	apply_manifest_on(host, "class { 'docker': docker_ee => true, extra_parameters => '\"insecure-registries\": [ \"#{@windows_ip}:5000\" ]' }")
	docker_path = '/cygdrive/c/Program Files/Docker'
	host.add_env_var('PATH', docker_path)
	host.add_env_var('TEMP', 'C:\Users\Administrator\AppData\Local\Temp')
	puts 'Waiting for box to come online'
	sleep 300
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Mon, Aug 18, 10:18 PM (5 d, 13 h ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 3340606

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions