Reworking paths to allow non-root usage and support multiple instances. Fixes T483
ClosedPublic
Actions

Authored by tflink on May 26 2015, 9:13 PM.

Details

Reviewers

Maniphest Tasks

T483: testcloud should work without root permissions

Commits

rTCLOUD19fe2cfcf17c: Fixing botched PR to allow non-root usage. Actually fixes T483
rTCLOUDe364137cb227: Allow non-root usage and support multiple instances. Fixes T483 - Changes…

Summary

This is the first step in what will be a rather large change to testCloud.
The code is still a bit messy and atomic support doesn't work with this but
I wanted to keep these changes as bite-sized as possible - the missing funcationlity
will be added back later and code will get cleaner as the entire refactor
progresses

Test Plan

unit tests pass, vms are still booted from cli interface

Diff Detail

Repository

rTCLOUD testcloud

Branch

feature/T483-noroot-permissions

Lint

No Linters Available

Unit

No Unit Test Coverage

tflink retitled this revision from to Reworking paths to allow non-root usage and support multiple instances. Fixes T483.May 26 2015, 9:13 PM

tflink updated this object.

tflink edited the test plan for this revision. (Show Details)

tflink added a reviewer: roshi.

Herald added a subscriber: tflink. · View Herald TranscriptMay 26 2015, 9:13 PM

tflink added a task: T483: testcloud should work without root permissions.May 26 2015, 9:13 PM

check for existing file before re-downloading image

After talking with @roshi about this - it turns out that I was relying on some polkit stuff that is configured/setup by default with most DEs but doesn't always work with custom setups and doesn't work with headless boxes.

To fix this, create a /etc/polkit-1/localauthority/50-local.d/50-nonrootlivirt.pkla file with the following contents

[nonroot libvirt system connection]
Identity=unix-group:testcloud
Action=org.libvirt.unix.manage
ResultActive=yes
ResultInactive=yes
ResultAny=yes

Then restart polkit (systemctl restart polkit) and make sure that your user is in the testcloud unix group (or subsitute any other group name as long as it matches the pkla file - this is only an example).

If the following command completes with retcode 0, this testcloud patch should work as a non-root user.

pkcheck --action-id org.libvirt.unix.manage --allow-user-interaction --process $BASHPID

Just update the docs with the dirs, and I think it's good to go.

README.rst
23	I think the dirs it needs are /var/lib/testCloud/{instances,cache} - it won't automagically make them.

This revision now requires changes to proceed.Jun 1 2015, 6:26 PM

In D376#6904, @roshi wrote:

Just update the docs with the dirs, and I think it's good to go.

Yeah, makes sense. We may want to make that more automagical at some point but it's not that way now. I'll fix the docs quick, including the polkit stuff.

updating docs to describe the currently required setup

Looks good to me.

This revision is now accepted and ready to land.Jun 1 2015, 6:52 PM

We really need to nail down this process better - doing both phab reviews and github PRs seems a little excessive to me.

Submitted PR: https://github.com/Rorosha/testCloud/pull/11

PR was merged into Rorosha/testCloud - closing revision

tflink mentioned this in T418: Have instances use their own metadata.Jun 1 2015, 7:11 PM

In D376#6899, @tflink wrote:
After talking with @roshi about this - it turns out that I was relying on some polkit stuff that is configured/setup by default with most DEs but doesn't always work with custom setups and doesn't work with headless boxes.

To fix this, create a /etc/polkit-1/localauthority/50-local.d/50-nonrootlivirt.pkla file with the following contents
[nonroot libvirt system connection]
Identity=unix-group:testcloud
Action=org.libvirt.unix.manage
ResultActive=yes
ResultInactive=yes
ResultAny=yes
Then restart polkit (systemctl restart polkit) and make sure that your user is in the testcloud unix group (or subsitute any other group name as long as it matches the pkla file - this is only an example).

@tflink This is interesting, what system have you tried this with? Because since Fedora 18 the old .pkla ini files should not be supported and javascript .rules files should be used instead. Not sure if there's some compatibility mode, but I'm quite sure I needed to adjust my own rules to the new syntax.

Here's an example of the polkit syntax change:
https://ask.fedoraproject.org/en/question/9871/mount-ntfs-partition-on-demand-without-password/?answer=15877#post-id-15877

In D376#6959, @kparal wrote:

@tflink This is interesting, what system have you tried this with? Because since Fedora 18 the old .pkla ini files should not be supported and javascript .rules files should be used instead. Not sure if there's some compatibility mode, but I'm quite sure I needed to adjust my own rules to the new syntax.

I tried the javascript syntax and couldn't get it to work on systems that didn't have a polkit agent on them. The only way I was able to get it to work on headless or non-standard-DE systems was to use the ini-style pkla file

Reading through the docs, the only solution I see that doesn't involve localauthority (the old ini style polkit conf) is to write a custom polkit agent and make sure it's started on headless systems.

But given the scarcity of docs about polkit and how to short-circuit the authentication bits (or have ssh key auth be enough) for non-human users, I could easily be wrong.

Revision Contents

		Path
M		README.rst (26 lines)
M		conf/settings-example.py (7 lines)
M		test/test_config.py (16 lines)
M		test/test_image.py (22 lines)
M		test/test_instance.py (38 lines)
M		testCloud/cli.py (150 lines)
M		testCloud/config.py (7 lines)
M		testCloud/exceptions.py (13 lines)
A	M	testCloud/image.py (200 lines)
A	M	testCloud/instance.py (277 lines)
D	M	testCloud/libtestcloud.py (374 lines)
M		testCloud/util.py (59 lines)

Diff	ID	Base	Description	Created	Lint	Unit
Base			Base
Diff 1	1004	d6f1e9d		May 26 2015, 9:13 PM	★	★
Diff 2	1006	d6f1e9d	- check for existing file before re-downloading image	May 27 2015, 8:54 PM	★	★
Diff 3	1011	d6f1e9d	- updating docs to describe the currently required setup	Jun 1 2015, 6:51 PM	★	★

Commit	Tree	Parents	Author	Summary	Date
eff51b186961	0b07c662c6e4	0795a057ad9f	Tim Flink	updating docs to describe the currently required setup	Jun 1 2015, 6:50 PM
0795a057ad9f	6e9f6ea1b2fb	f4e34751a5c9	Tim Flink	check for existing file before re-downloading image	May 27 2015, 8:53 PM
f4e34751a5c9	11abf93cd962	d6f1e9d1cca8	Tim Flink	Reworking paths to allow non-root usage and support multiple instances. Fixes… (Show More…)	May 20 2015, 10:11 PM

Diff 1011

View Options

README.rst

Show All 14 Lines
15	- python-requests (for whatever python version you're running)	15		- python-requests (for whatever python version you're running)
16		16
17	Optional:	17		Optional:
18	- py.test (if you plan on running or working on the tests)	18		- py.test (if you plan on running or working on the tests)
19		19
20	All of these packages are in the Fedora repos (and likely other distros as	20		All of these packages are in the Fedora repos (and likely other distros as
21	well).	21		well).
22		22
		23		For the moment, the follwing directories need to exist with permissions that
			roshiUnsubmitted Not Done I think the dirs it needs are /var/lib/testCloud/{instances,cache} - it won't automagically make them.
		24		allow modification by any permitted user::
		25
		26		/var/lib/testCloud/
		27		/var/lib/testCloud/instances
		28		/var/lib/testCloud/cache
		29
		30		This will be automagical in a future version of testCloud and is a side-effect
		31		of the current refactoring/transition process.
		32
		33		If you are running testCloud as a non-administrative user (ie. not in wheel) or
		34		on a system that doesn't have a polkit agent running (custom setups, headless
		35		systems etc.), you may need to adjust local polkit configuration to allow non-root
		36		users to manage VMs with libvirt. Add the following data into ``/etc/polkit-1/localauthority/50-local.d/50-nonrootlivirt.pkla``::
		37
		38		[nonroot libvirt system connection]
		39		Identity=unix-group:testcloud
		40		Action=org.libvirt.unix.manage
		41		ResultActive=yes
		42		ResultInactive=yes
		43		ResultAny=yes
		44
		45		After writing that file, restart polkit (``systemctl restart polkit``) and if
		46		the user in question is a member of the unix group ``testcloud``, that user
		47		should be able to run testCloud with no additional permissions.
		48
23	Usage	49		Usage
24	-----	50		-----
25		51
26	The usage varies slightly between using the git checkout and installing the	52		The usage varies slightly between using the git checkout and installing the
27	module. To run testCloud straight from the git checkout, use	53		module. To run testCloud straight from the git checkout, use
28		54
29	.. code:: bash	55		.. code:: bash
30		56
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

View Options

conf/settings-example.py

1	import os	1	import os
2		2
3		3
4	# Commented out default values with details are displayed below. To override	4	# Commented out default values with details are displayed below. To override
5	# these default values, uncomment the values, rename the file to settings.py	5	# these default values, uncomment the values, rename the file to settings.py
6	# and place it in a supported config location	6	# and place it in a supported config location
7		7
8	# Do not modify this file directly, it will not be picked up unless the filename	8	# Do not modify this file directly, it will not be picked up unless the filename
9	# is changed to settings.py	9	# is changed to settings.py
10		10
11	#DOWNLOAD_PROGRESS = True	11	#DOWNLOAD_PROGRESS = True
12		12
13	# Directories testCloud cares about	13	# Directories for data and cached downloaded images
14		14	#DATA_DIR = "/var/lib/testCloud/"
15	#PRISTINE = "/home/{}/.local/share/testcloud/images/".format(os.getlogin())	15	#CACHE_DIR = "/var/lib/testCloud/cache"
16	#LOCAL_DOWNLOAD_DIR = "/var/tmp/"
17		16
18	# Data for cloud-init	17	# Data for cloud-init
19		18
20	#PASSWORD = 'passw0rd'	19	#PASSWORD = 'passw0rd'
21	#HOSTNAME = 'testcloud'	20	#HOSTNAME = 'testcloud'
22		21
23	#META_DATA = """instance-id: iid-123456	22	#META_DATA = """instance-id: iid-123456
24	#local-hostname: %s	23	#local-hostname: %s
Show All 18 Lines

View Options

test/test_config.py

1	#!/usr/bin/env python	1		#!/usr/bin/env python
2	# -- coding: utf-8 --	2		# -- coding: utf-8 --
3	# Copyright 2015, Red Hat, Inc.	3		# Copyright 2015, Red Hat, Inc.
4	# License: GPL-2.0+ <http://spdx.org/licenses/GPL-2.0+>	4		# License: GPL-2.0+ <http://spdx.org/licenses/GPL-2.0+>
5	# See the LICENSE file for more details on Licensing	5		# See the LICENSE file for more details on Licensing
6		6
7	from testCloud import config	7		from testCloud import config
8		8
9		9
10	REF_DOWNLOAD_DIR = "/some/random/dir/for/testing/"	10		REF_DATA_DIR = "/some/random/dir/for/testing/"
11	REF_CONF_CONTENTS = """LOCAL_DOWNLOAD_DIR = "{}"	11		REF_CACHE_DIR = "/some/random/dir/for/testing/cache/"
12	""".format(REF_DOWNLOAD_DIR)	12		REF_CONF_CONTENTS = """DATA_DIR = "{}"
		13		CACHE_DIR = "{}/cache"
		14		""".format(REF_DATA_DIR, REF_CACHE_DIR)
13		15
14	class TestConfig(object):	16		class TestConfig(object):
15	def setup_method(self, method):	17		def setup_method(self, method):
16	config._config = None	18		config._config = None
17		19
18	def test_get_config_object(self, monkeypatch):	20		def test_get_config_object(self, monkeypatch):
19	'''Simple test to grab a config object, will return default config	21		'''Simple test to grab a config object, will return default config
20	values.	22		values.
Show All 21 Lines		42	def test_load_config_object(self, tmpdir):
42		44
43	refdir = tmpdir.mkdir('conf')	45		refdir = tmpdir.mkdir('conf')
44	ref_conf_filename = '{}/{}'.format(refdir, config.CONF_FILE)	46		ref_conf_filename = '{}/{}'.format(refdir, config.CONF_FILE)
45	with open(ref_conf_filename, 'w+') as ref_conffile:	47		with open(ref_conf_filename, 'w+') as ref_conffile:
46	ref_conffile.write(REF_CONF_CONTENTS)	48		ref_conffile.write(REF_CONF_CONTENTS)
47		49
48	test_config = config._load_config(ref_conf_filename)	50		test_config = config._load_config(ref_conf_filename)
49		51
50	assert test_config.LOCAL_DOWNLOAD_DIR == REF_DOWNLOAD_DIR	52		assert test_config.DATA_DIR == REF_DATA_DIR
51		53
52	def test_merge_config_file(self, tmpdir):	54		def test_merge_config_file(self, tmpdir):
53	'''merge loaded config object with defaults, make sure that the defaults	55		'''merge loaded config object with defaults, make sure that the defaults
54	are overridden.	56		are overridden.
55	'''	57		'''
56		58
57	refdir = tmpdir.mkdir('conf')	59		refdir = tmpdir.mkdir('conf')
58	ref_conf_filename = '{}/{}'.format(refdir, config.CONF_FILE)	60		ref_conf_filename = '{}/{}'.format(refdir, config.CONF_FILE)
59	with open(ref_conf_filename, 'w+') as ref_conffile:	61		with open(ref_conf_filename, 'w+') as ref_conffile:
60	ref_conffile.write(REF_CONF_CONTENTS)	62		ref_conffile.write(REF_CONF_CONTENTS)
61		63
62	test_config_obj = config._load_config(ref_conf_filename)	64		test_config_obj = config._load_config(ref_conf_filename)
63		65
64	test_config = config.ConfigData()	66		test_config = config.ConfigData()
65	assert test_config.LOCAL_DOWNLOAD_DIR != REF_DOWNLOAD_DIR	67		assert test_config.DATA_DIR != REF_DATA_DIR
66		68
67	test_config.merge_object(test_config_obj)	69		test_config.merge_object(test_config_obj)
68	assert test_config.LOCAL_DOWNLOAD_DIR == REF_DOWNLOAD_DIR	70		assert test_config.DATA_DIR == REF_DATA_DIR
69		71
70	def test_load_merge_config_file(self, tmpdir, monkeypatch):	72		def test_load_merge_config_file(self, tmpdir, monkeypatch):
71	'''get config, making sure that an addional config file is found. make	73		'''get config, making sure that an addional config file is found. make
72	sure that default values are properly overridden.	74		sure that default values are properly overridden.
73	'''	75		'''
74		76
75	refdir = tmpdir.mkdir('conf')	77		refdir = tmpdir.mkdir('conf')
76	ref_conf_filename = '{}/{}'.format(refdir, config.CONF_FILE)	78		ref_conf_filename = '{}/{}'.format(refdir, config.CONF_FILE)
77	with open(ref_conf_filename, 'w+') as ref_conffile:	79		with open(ref_conf_filename, 'w+') as ref_conffile:
78	ref_conffile.write(REF_CONF_CONTENTS)	80		ref_conffile.write(REF_CONF_CONTENTS)
79		81
80	monkeypatch.setattr(config, 'CONF_DIRS', [str(refdir)])	82		monkeypatch.setattr(config, 'CONF_DIRS', [str(refdir)])
81	test_config = config.get_config()	83		test_config = config.get_config()
82		84
83	assert test_config.LOCAL_DOWNLOAD_DIR == REF_DOWNLOAD_DIR	85		assert test_config.DATA_DIR == REF_DATA_DIR
84		86

View Options

test/test_image.py

1	#!/usr/bin/env python	1	#!/usr/bin/env python
2	# -- coding: utf-8 --	2	# -- coding: utf-8 --
3	# Copyright 2015, Red Hat, Inc.	3	# Copyright 2015, Red Hat, Inc.
4	# License: GPL-2.0+ <http://spdx.org/licenses/GPL-2.0+>	4	# License: GPL-2.0+ <http://spdx.org/licenses/GPL-2.0+>
5	# See the LICENSE file for more details on Licensing	5	# See the LICENSE file for more details on Licensing
6		6
7	""" This module is for testing the behaviour of the Image class."""	7	""" This module is for testing the behaviour of the Image class."""
8		8
9	import pytest	9	import pytest
10		10
11	from testCloud import libtestcloud	11	from testCloud import image
12	from testCloud.exceptions import TestCloudImageError	12	from testCloud.exceptions import TestCloudImageError
13		13
14	class TestImage:	14	class TestImage:
15		15
16	def test_image_download_path(self):	16	def test_image_download_path(self):
17	pass	17	pass
18		18
19	def test_image_name(self):	19	def test_image_name(self):
20	pass	20	pass
21		21
22	def test_download(self):	22	def test_download(self):
23	pass	23	pass
24		24
25	def test_save_pristine(self):	25	# def test_save_pristine(self):
26	pass	26	# pass
27		27	#
28	def test_load_pristine(self):	28	# def test_load_pristine(self):
29	pass	29	# pass
30		30
31	class TestImageUriProcess(object):	31	class TestImageUriProcess(object):
32	"""The basic idea of what these tests do is to make sure that uris are	32	"""The basic idea of what these tests do is to make sure that uris are
33	parsed properly. http, https and file are OK and supported. ftp is an	33	parsed properly. http, https and file are OK and supported. ftp is an
34	an example of a type which is not currently supported and should raise an	34	an example of a type which is not currently supported and should raise an
35	exception."""	35	exception."""
36		36
37	def setup_method(self, method):	37	def setup_method(self, method):
38	self.image_name = 'image.img'	38	self.image_name = 'image.img'
39	self.len_data = 3	39	self.len_data = 3
40		40
41	def test_http_ur1(self):	41	def test_http_ur1(self):
42	ref_type = 'http'	42	ref_type = 'http'
43	ref_path = 'localhost/images/{}'.format(self.image_name)	43	ref_path = 'localhost/images/{}'.format(self.image_name)
44	ref_uri = '{}://{}'.format(ref_type, ref_path)	44	ref_uri = '{}://{}'.format(ref_type, ref_path)
45		45
46	test_image = libtestcloud.Image(ref_uri)	46	test_image = image.Image(ref_uri)
47	test_data = test_image._process_uri(ref_uri)	47	test_data = test_image._process_uri(ref_uri)
48		48
49	assert len(test_data) == self.len_data	49	assert len(test_data) == self.len_data
50	assert test_data['type'] == ref_type	50	assert test_data['type'] == ref_type
51	assert test_data['name'] == self.image_name	51	assert test_data['name'] == self.image_name
52	assert test_data['path'] == ref_path	52	assert test_data['path'] == ref_path
53		53
54	def test_https_uri(self):	54	def test_https_uri(self):
55	ref_type = 'https'	55	ref_type = 'https'
56	ref_path = 'localhost/images/{}'.format(self.image_name)	56	ref_path = 'localhost/images/{}'.format(self.image_name)
57	ref_uri = '{}://{}'.format(ref_type, ref_path)	57	ref_uri = '{}://{}'.format(ref_type, ref_path)
58		58
59	test_image = libtestcloud.Image(ref_uri)	59	test_image = image.Image(ref_uri)
60	test_data = test_image._process_uri(ref_uri)	60	test_data = test_image._process_uri(ref_uri)
61		61
62	assert len(test_data) == self.len_data	62	assert len(test_data) == self.len_data
63	assert test_data['type'] == ref_type	63	assert test_data['type'] == ref_type
64	assert test_data['name'] == self.image_name	64	assert test_data['name'] == self.image_name
65	assert test_data['path'] == ref_path	65	assert test_data['path'] == ref_path
66		66
67	def test_file_uri(self):	67	def test_file_uri(self):
68	ref_type = 'file'	68	ref_type = 'file'
69	ref_path = '/srv/images/{}'.format(self.image_name)	69	ref_path = '/srv/images/{}'.format(self.image_name)
70	ref_uri = '{}://{}'.format(ref_type, ref_path)	70	ref_uri = '{}://{}'.format(ref_type, ref_path)
71		71
72	test_image = libtestcloud.Image(ref_uri)	72	test_image = image.Image(ref_uri)
73	test_data = test_image._process_uri(ref_uri)	73	test_data = test_image._process_uri(ref_uri)
74		74
75	assert len(test_data) == self.len_data	75	assert len(test_data) == self.len_data
76	assert test_data['type'] == ref_type	76	assert test_data['type'] == ref_type
77	assert test_data['name'] == self.image_name	77	assert test_data['name'] == self.image_name
78	assert test_data['path'] == ref_path	78	assert test_data['path'] == ref_path
79		79
80	def test_invalid_uri_type(self):	80	def test_invalid_uri_type(self):
81	ref_type = 'ftp'	81	ref_type = 'ftp'
82	ref_path = '/localhost/images/{}'.format(self.image_name)	82	ref_path = '/localhost/images/{}'.format(self.image_name)
83	ref_uri = '{}://{}'.format(ref_type, ref_path)	83	ref_uri = '{}://{}'.format(ref_type, ref_path)
84		84
85	with pytest.raises(TestCloudImageError):	85	with pytest.raises(TestCloudImageError):
86	libtestcloud.Image(ref_uri)	86	image.Image(ref_uri)
87		87
88	def test_invalid_uri(self):	88	def test_invalid_uri(self):
89	ref_uri = 'leprechaunhandywork'	89	ref_uri = 'leprechaunhandywork'
90		90
91	with pytest.raises(TestCloudImageError):	91	with pytest.raises(TestCloudImageError):
92	libtestcloud.Image(ref_uri)	92	image.Image(ref_uri)

View Options

test/test_instance.py

1	#!/usr/bin/env python	1	#!/usr/bin/env python
2	# -- coding: utf-8 --	2	# -- coding: utf-8 --
3	# Copyright 2015, Red Hat, Inc.	3	# Copyright 2015, Red Hat, Inc.
4	# License: GPL-2.0+ <http://spdx.org/licenses/GPL-2.0+>	4	# License: GPL-2.0+ <http://spdx.org/licenses/GPL-2.0+>
5	# See the LICENSE file for more details on Licensing	5	# See the LICENSE file for more details on Licensing
6		6
7	""" This module is for testing the behaviour of the Image class."""	7	""" This module is for testing the behaviour of the Image class."""
8		8
		9	import os
		10
		11	import mock
		12
		13	from testCloud import instance, config
		14
9	class TestInstance:	15	class TestInstance:
10		16
11	def test_expand_qcow(self):	17	def test_expand_qcow(self):
12	pass	18	pass
13		19
14	def test_create_seed(self):	20	def test_create_seed(self):
15	pass	21	pass
16		22
17	def test_set_seed_path(self):	23	def test_set_seed_path(self):
18	pass	24	pass
19		25
20	def test_download_initrd_and_kernel(self):	26	def test_download_initrd_and_kernel(self):
21	pass	27	pass
22		28
23	def test_boot_base(self):	29	def test_boot_base(self):
24	pass	30	pass
25		31
26	def test_boot_atomic(self):	32	def test_boot_atomic(self):
27	pass	33	pass
28		34
29	def test_boot_pristine(self):	35	def test_boot_pristine(self):
30	pass	36	pass
		37
		38	class TestFindInstance(object):
		39
		40	def setup_method(self, method):
		41	self.conf = config.ConfigData()
		42
		43	def test_non_existant_instance(self, monkeypatch):
		44	ref_name = 'test-123'
		45	ref_image = 'someimage.qcow2'
		46
		47	stub_listdir = mock.Mock()
		48	stub_listdir.return_value = []
		49	monkeypatch.setattr(os, 'listdir', stub_listdir)
		50
		51	test_instance = instance.find(ref_name, ref_image)
		52
		53	assert test_instance is None
		54
		55
		56	def test_find_exist_instance(self, monkeypatch):
		57	ref_name = 'test-123'
		58	ref_image = 'someimage.qcow2'
		59	ref_path = os.path.join(self.conf.DATA_DIR,
		60	'instances/{}'.format(ref_name))
		61
		62	stub_listdir = mock.Mock()
		63	stub_listdir.return_value = [ref_name]
		64	monkeypatch.setattr(os, 'listdir', stub_listdir)
		65
		66	test_instance = instance.find(ref_name, ref_image)
		67
		68	assert test_instance == ref_path

View Options

testCloud/cli.py

1	#!/usr/bin/env python	1	#!/usr/bin/env python
2	# -- coding: utf-8 --	2	# -- coding: utf-8 --
3	# Copyright 2015, Red Hat, Inc.	3	# Copyright 2015, Red Hat, Inc.
4	# License: GPL-2.0+ <http://spdx.org/licenses/GPL-2.0+>	4	# License: GPL-2.0+ <http://spdx.org/licenses/GPL-2.0+>
5	# See the LICENSE file for more details on Licensing	5	# See the LICENSE file for more details on Licensing
6		6
7	"""	7	"""
8	This is the main script for running testCloud.	8	This is the primary user entry point for testCloud
9	"""	9	"""
10		10
11	import os	11	import argparse
12	from time import sleep	12	import logging
13	import libvirt
14		13
15	from . import config	14	from . import config
		15	from . import image
		16	from . import instance
		17
		18	# these are used in commented out code, may be reactivated
		19	#import os
		20	from time import sleep
16	from . import util	21	from . import util
17	from . import libtestcloud as libtc	22	#import libvirt
		23	from .exceptions import DomainNotFoundError
18		24
19	config_data = config.get_config()	25	config_data = config.get_config()
20		26
21	from .libtestcloud import log	27	log = logging.getLogger('libtestcloud')
22		28	logging.basicConfig(format='%(levelname)s:%(message)s', level=logging.DEBUG)
23	def install(
24	image_url, instance_name, ram=512, graphics=False, vnc=False, atomic=False,
25	pristine=False):
26	"""Run through all the steps."""
27
28	log.info("Cleaning dirs...")
29	util.clean_dirs()
30	util.create_dirs()
31
32	base_path = config_data.LOCAL_DOWNLOAD_DIR + '/testCloud'
33
34	# Create the data cloud-init needs
35	log.info("Creating meta-data...")
36	util.create_user_data(base_path, config_data.PASSWORD, atomic=atomic)
37	util.create_meta_data(base_path, config_data.HOSTNAME)
38
39	# Instantiate the image and the instance from the image
40
41	image = libtc.Image(image_url)
42
43	vm = libtc.Instance(instance_name, image)
44
45	# Set all the instance attributes passed from the cmdline
46	vm.ram = ram
47	vm.vnc = vnc
48	vm.graphics = graphics
49	vm.atomic = atomic
50
51	vm.create_seed_image(base_path + '/meta', base_path)
52
53	boot = False
54
55	if not os.path.isfile(config_data.PRISTINE + vm.image):
56	log.info("image is not cached, preparing new image...")
57	image.prepare()
58
59	else:
60	log.info("Using existing image...")
61
62
63	if not os.path.isfile(config_data.LOCAL_DOWNLOAD_DIR + image.name):
64	image.load_pristine()
65	if pristine:
66	log.debug("Copying from pristine image...")
67
68	# Remove existing image if it exists
69	if os.path.exists(config_data.LOCAL_DOWNLOAD_DIR + image.name):
70	os.remove(config_data.LOCAL_DOWNLOAD_DIR + image.name)
71
72	image.load_pristine()
73
74	# Note that we just need to boot, not install
75	else:
76	boot = True
77
78	# Determine if we want to grow the disk. Currently we only do this if the
79	# instance to be booted is a fresh Atomic image.
80
81	expand_disk = False
82
83	if atomic and pristine:
84	expand_disk = True
85
86	if pristine:
87	vm.selfdestruct()
88	vm.create_instance()
89	vm.spawn(expand_disk=expand_disk)
90
91	else:
92	if boot:
93	vm.boot()
94	else:
95	vm.create_instance()
96	vm.spawn(expand_disk=expand_disk)
97
98	return vm
99
100
101	def main():
102	import argparse
103		29
		30	def get_argparser():
104	parser = argparse.ArgumentParser()	31	parser = argparse.ArgumentParser()
105	parser.add_argument("url",	32	parser.add_argument("url",
106	help="URL to qcow2 image is required.",	33	help="URL to qcow2 image is required.",
107	type=str)	34	type=str)
108	parser.add_argument("--ram",	35	parser.add_argument("--ram",
109	help="Specify the amount of ram for the VM.",	36	help="Specify the amount of ram for the VM.",
110	type=int,	37	type=int,
111	default=512)	38	default=512)
112	parser.add_argument("--no-graphic",	39	parser.add_argument("--no-graphic",
113	help="Turn off graphical display.",	40	help="Turn off graphical display.",
114	action="store_true")	41	action="store_true")
115	parser.add_argument("--vnc",	42	parser.add_argument("--vnc",
116	help="Turns on vnc at :1 to the instance.",	43	help="Turns on vnc at :1 to the instance.",
117	action="store_true")	44	action="store_true")
118	parser.add_argument("--atomic",	45	parser.add_argument("--atomic",
119	help="Use this flag if you're booting an Atomic Host.",	46	help="Use this flag if you're booting an Atomic Host.",
120	action="store_true")	47	action="store_true")
121	parser.add_argument("--pristine",	48	parser.add_argument("--pristine",
122	help="Use a clean copy of an image.",	49	help="Use a clean copy of an image.",
123	action="store_true")	50	action="store_true")
124	parser.add_argument("--name",	51	parser.add_argument("--name",
125	help="A unique name to use for your instance.",	52	help="A unique name to use for your instance.",
126	default='testCloud')	53	default='testCloud')
		54
		55	return parser
		56
		57	def main():
		58	parser = get_argparser()
127	args = parser.parse_args()	59	args = parser.parse_args()
128		60
129	install(args.url,	61	# get/find image
130	args.name,	62	# look for existing instance
131	args.ram,	63	# if not exist:
132	graphics=args.no_graphic,	64	# prepare metadata
133	vnc=args.vnc,	65	# boot vm
134	atomic=args.atomic,	66
135	pristine=args.pristine)	67	tc_image = image.Image(args.url)
		68	tc_image.prepare()
		69
		70	instance_path = instance.find(args.name, tc_image.name)
		71
		72	# for the moment, rebooting existing instances is noworky, so blow up early
		73	if instance_path is not None:
		74	raise NotImplementedError("testCloud does not yet support booting " \
		75	"existing instances. Please remove {} before"\
		76	" continuing".format(instance_path))
		77
		78	else:
		79	tc_instance = instance.Instance(args.name, tc_image)
		80
		81	# prepare instance
		82	tc_instance.prepare()
		83
		84	# boot instance
		85	tc_instance.spawn_vm()
		86
		87	# look for data about instance (mac, IP, etc.)
136		88
		89	# install(args.url,
		90	# args.name,
		91	# args.ram,
		92	# graphics=args.no_graphic,
		93	# vnc=args.vnc,
		94	# atomic=args.atomic,
		95	# pristine=args.pristine)
		96	#
137	# It takes a bit for the instance to get registered in virsh,	97	# It takes a bit for the instance to get registered in virsh,
138	# so here we keep asking for the domain we created until virsh	98	# so here we keep asking for the domain we created until virsh
139	# finally decides to cough up the information.	99	# finally decides to cough up the information.
140		100
141	log.info("Don't worry about these 'QEMU Driver' errors. libvirt is whiny " + \	101	log.info("Don't worry about these 'QEMU Driver' errors. libvirt is whiny " + \
142	"and has no method to shut it up...\n")	102	"and has no method to shut it up...\n")
143		103
144	for _ in xrange(100):	104	for _ in xrange(100):
145	vm_xml = util.get_vm_xml(args.name)	105	vm_xml = util.get_vm_xml(args.name)
146	if vm_xml is not None:	106	if vm_xml is not None:
147	break	107	break
148		108
149	else:	109	else:
150	sleep(.2)	110	sleep(.2)
151	else:	111	else:
152	raise libtc.DomainNotFoundError	112	raise DomainNotFoundError
153		113
154	vm_mac = util.find_mac(vm_xml)	114	vm_mac = util.find_mac(vm_xml)
155	vm_mac = vm_mac[0]	115	vm_mac = vm_mac[0]
156		116
157	# The arp cache takes some time to populate, so this keeps looking	117	# The arp cache takes some time to populate, so this keeps looking
158	# for the entry until it shows up.	118	# for the entry until it shows up.
159		119
160	for _ in xrange(100):	120	for _ in xrange(100):
Show All 10 Lines

View Options

testCloud/config.py

Show First 20 Lines • Show All 78 Lines • ▼ Show 20 Line(s)		78	class ConfigData(object):
79	'''Holds configuration data for TestCloud. Is initialized with default	79		'''Holds configuration data for TestCloud. Is initialized with default
80	values which can be overridden.	80		values which can be overridden.
81	'''	81		'''
82		82
83	DOWNLOAD_PROGRESS = True	83		DOWNLOAD_PROGRESS = True
84		84
85	# Directories testCloud cares about	85		# Directories testCloud cares about
86		86
87	PRISTINE = "/home/{}/.local/share/testcloud/images/".format(os.getlogin())	87		DATA_DIR = "/var/lib/testCloud"
88	LOCAL_DOWNLOAD_DIR = "/var/tmp/"	88		CACHE_DIR = "/var/lib/testCloud/cache"
		89
		90		# PRISTINE = "/home/{}/.local/share/testcloud/images/".format(os.getlogin())
		91		# LOCAL_DOWNLOAD_DIR = "/var/tmp/"
89		92
90	# Data for cloud-init	93		# Data for cloud-init
91		94
92	PASSWORD = 'passw0rd'	95		PASSWORD = 'passw0rd'
93	HOSTNAME = 'testcloud'	96		HOSTNAME = 'testcloud'
94		97
95	META_DATA = """instance-id: iid-123456	98		META_DATA = """instance-id: iid-123456
96	local-hostname: %s	99		local-hostname: %s
Show All 30 Lines

View Options

testCloud/exceptions.py

1	#!/usr/bin/env python	1	#!/usr/bin/env python
2	# -- coding: utf-8 --	2	# -- coding: utf-8 --
3	# Copyright 2015, Red Hat, Inc.	3	# Copyright 2015, Red Hat, Inc.
4	# License: GPL-2.0+ <http://spdx.org/licenses/GPL-2.0+>	4	# License: GPL-2.0+ <http://spdx.org/licenses/GPL-2.0+>
5	# See the LICENSE file for more details on Licensing	5	# See the LICENSE file for more details on Licensing
6		6
7	"""	7	"""
8	Exceptions used with testCloud	8	Exceptions used with testCloud
9	"""	9	"""
10		10
11		11
12	class TestCloudException(BaseException):	12	class TestCloudException(BaseException):
13	"""Common ancestor for all TestCloud exceptions"""	13	"""Common ancestor for all TestCloud exceptions"""
14	pass	14	pass
15		15
16
17	class TestCloudImageError(TestCloudException):	16	class TestCloudImageError(TestCloudException):
18	"""Exception for errors having to do with images and image fetching"""	17	"""Exception for errors having to do with images and image fetching"""
19	pass	18	pass
20		19
		20	class TestCloudInstanceError(TestCloudException):
		21	"""Exception for errors having to do with instances and instance prep"""
		22	pass
		23
		24	class DomainNotFoundError(BaseException):
		25	"""Exception to raise if the queried domain can't be found."""
		26
		27	def __init__(self):
		28	self.value = "Could not find the requested virsh domain, did it register?"
		29
		30	def __str__(self):
		31	return repr(self.value)

View Options

testCloud/image.py

This file was added.

		1		#!/usr/bin/env python
		2		# -- coding: utf-8 --
		3		# Copyright 2015, Red Hat, Inc.
		4		# License: GPL-2.0+ <http://spdx.org/licenses/GPL-2.0+>
		5		# See the LICENSE file for more details on Licensing
		6
		7		"""
		8		This is a module for downloading fedora cloud images (and probably any other
		9		qcow2) and then booting them locally with qemu.
		10		"""
		11
		12		import sys
		13		import os
		14		import subprocess
		15		import re
		16		import shutil
		17		import logging
		18
		19		import requests
		20
		21		from . import config
		22		from .exceptions import TestCloudImageError
		23
		24		config_data = config.get_config()
		25
		26		log = logging.getLogger('testCloud.image')
		27
		28		class Image(object):
		29		"""Handles base cloud images and prepares them for boot. This includes
		30		downloading images from remote systems (http, https supported) or copying
		31		from mounted local filesystems.
		32		"""
		33
		34		def __init__(self, uri):
		35		"""Create a new Image object for TestCloud
		36
		37		:param uri: URI for the image to be represented. this URI must be of a
		38		supported type (http, https, file)
		39		:raises TaskotronImageError: if the URI is not of a supported type or cannot be parsed
		40		"""
		41
		42		self.uri = uri
		43
		44		uri_data = self._process_uri(uri)
		45
		46		self.name = uri_data['name']
		47		self.uri_type = uri_data['type']
		48
		49		if self.uri_type == 'file':
		50		self.remote_path = uri_data['path']
		51		else:
		52		self.remote_path = uri
		53
		54		self.local_path = "{}/{}".format(config_data.CACHE_DIR, self.name)
		55
		56		def _process_uri(self, uri):
		57		"""Process the URI given to find the type, path and imagename contained
		58		in that URI.
		59
		60		:param uri: string URI to be processed
		61		:return: dictionary containing 'type', 'name' and 'path'
		62		:raise TestCloudImageError: if the URI is invalid or uses an unsupported transport
		63		"""
		64
		65		type_match = re.search(r'(http\|https\|file)://([\w\.\-/]+)', uri)
		66
		67		if not type_match:
		68		raise TestCloudImageError('invalid uri: only http, https and file uris are supported: {}'.format(uri))
		69
		70		uri_type = type_match.group(1)
		71		uri_path = type_match.group(2)
		72
		73		name_match = re.findall('([\w\.\-]+)', uri)
		74
		75		if not name_match:
		76		raise TestCloudImageError('invalid uri: could not find image name: {}'.format(uri))
		77
		78		image_name = name_match[-1]
		79		return {'type': uri_type, 'name': image_name, 'path': uri_path}
		80
		81
		82		def _download_remote_image(self, remote_url, local_path):
		83		"""Download a remote image to the local system, outputting download
		84		progress as it's downloaded.
		85
		86		:param remote_url: URL of the image
		87		:param local_path: local path (including filename) that the image
		88		will be downloaded to
		89		"""
		90
		91		u = requests.get(remote_url, stream=True)
		92
		93		try:
		94		with open(local_path + ".part", 'wb') as f:
		95		file_size = int(u.headers['content-length'])
		96
		97		log.info("Downloading {0} ({1} bytes)".format(self.name, file_size))
		98		bytes_downloaded = 0
		99		block_size = 4096
		100
		101		while True:
		102
		103		try:
		104
		105		for data in u.iter_content(block_size):
		106
		107		bytes_downloaded += len(data)
		108		f.write(data)
		109		bytes_remaining = float(bytes_downloaded) / file_size
		110		if config_data.DOWNLOAD_PROGRESS:
		111		# TODO: Improve this progress indicator by making
		112		# it more readable and user-friendly.
		113		status = r"{0}/{1} [{2:.2%}]".format(bytes_downloaded,
		114		file_size,
		115		bytes_remaining)
		116		status = status + chr(8) * (len(status) + 1)
		117		sys.stdout.write(status)
		118
		119		except TypeError:
		120		# Rename the file since download has completed
		121		os.rename(local_path + ".part", local_path)
		122		log.info("Succeeded at downloading {0}".format(self.name))
		123		break
		124
		125		except OSError:
		126		log.error("Problem writing to {}.".format(config_data.PRISTINE))
		127
		128		def _handle_file_url(self, source_path, dest_path):
		129		if not os.path.exists(dest_path):
		130		shutil.copy(source_path, dest_path)
		131
		132
		133		def _adjust_image_selinux(self, image_path):
		134		"""If SElinux is enabled on the system, change the context of that image
		135		file such that libguestfs and qemu can use it.
		136
		137		:param image_path: path to the image to change the context of
		138		"""
		139
		140		selinux_active = subprocess.call(['selinuxenabled'])
		141
		142		if selinux_active != 0:
		143		log.debug('SELinux not enabled, not changing context of'
		144		'image {}'.format(image_path))
		145		return
		146
		147		image_context = subprocess.call(['chcon',
		148		'-u', 'system_u',
		149		'-t', 'virt_content_t',
		150		image_path])
		151		if image_context == 0:
		152		log.debug('successfully changed SELinux context for '
		153		'image {}'.format(image_path))
		154		else:
		155		log.error('Error while changing SELinux context on '
		156		'image {}'.format(image_path))
		157
		158
		159		def prepare(self):
		160		"""Prepare the image for local use by either downloading the image from
		161		a remote location or copying it into the image cache from a locally
		162		mounted filesystem"""
		163
		164		# # Create the proper local upload directory if it doesn't exist.
		165		# if not os.path.exists(config_data.PRISTINE):
		166		# os.makedirs(config_data.PRISTINE)
		167
		168		log.debug("Local downloads will be stored in {}.".format(
		169		config_data.CACHE_DIR))
		170
		171		if self.uri_type == 'file':
		172		self._handle_file_url(self.remote_path, self.local_path)
		173		else:
		174		if not os.path.exists(self.local_path):
		175		self._download_remote_image(self.remote_path, self.local_path)
		176
		177		self._adjust_image_selinux(self.local_path)
		178
		179		return self.local_path
		180
		181		# def save_pristine(self):
		182		# """Save a copy of the downloaded image to the config_dataured PRISTINE dir.
		183		# Only call this after an image has been downloaded.
		184		# """
		185		#
		186		# subprocess.call(['cp',
		187		# self.local_path,
		188		# config_data.PRISTINE])
		189		#
		190		# log.debug('Copied fresh image to {0}...'.format(config_data.PRISTINE))
		191		#
		192		# def load_pristine(self):
		193		# """Load a pristine image to /tmp instead of downloading.
		194		# """
		195		# subprocess.call(['cp',
		196		# config_data.PRISTINE + self.name,
		197		# config_data.LOCAL_DOWNLOAD_DIR])
		198		#
		199		# log.debug('Copied fresh image to {} ...'.format(config_data.LOCAL_DOWNLOAD_DIR))
		200		#

View Options

testCloud/instance.py

This file was added.

		1		#!/usr/bin/env python
		2		# -- coding: utf-8 --
		3		# Copyright 2015, Red Hat, Inc.
		4		# License: GPL-2.0+ <http://spdx.org/licenses/GPL-2.0+>
		5		# See the LICENSE file for more details on Licensing
		6
		7		"""
		8		This is a module for downloading fedora cloud images (and probably any other
		9		qcow2) and then booting them locally with qemu.
		10		"""
		11
		12		import os
		13		import sys
		14		import subprocess
		15		import glob
		16		import logging
		17
		18		from . import config
		19		from .exceptions import TestCloudInstanceError
		20
		21		config_data = config.get_config()
		22
		23		log = logging.getLogger('testCloud.instance')
		24
		25		def find(name, image):
		26		instance_dir = '{}/instances'.format(config_data.DATA_DIR)
		27		instances = os.listdir(instance_dir)
		28
		29		for inst in instances:
		30		if name == inst:
		31		return os.path.join(instance_dir, inst)
		32
		33		return None
		34
		35		class Instance(object):
		36		"""The Instance class handles the creation, location and customization
		37		of existing testCloud instances (which are qcow2 backed from an Image)"""
		38
		39		def __init__(self, name, image):
		40		self.name = name
		41		self.image = image
		42		self.path = "{}/instances/{}".format(config_data.DATA_DIR, self.name)
		43		self.seed_path = "{}/{}-seed.img".format(self.path, self.name)
		44		self.meta_path = "{}/meta".format(self.path)
		45		self.local_disk = "{}/{}-local.qcow2".format(self.path, self.name)
		46
		47		self.ram = 512
		48		self.vnc = False
		49		self.graphics = False
		50		self.atomic = False
		51		self.seed = None
		52		self.kernel = None
		53		self.initrd = None
		54
		55		# get rid of
		56		self.backing_store = image.local_path
		57		self.image_path = config_data.CACHE_DIR + self.name + ".qcow2"
		58
		59		def prepare(self):
		60		# create the dirs needed for this instance
		61		self._create_dirs()
		62
		63		# generate metadata
		64		self._create_user_data(config_data.PASSWORD)
		65		self._create_meta_data(config_data.HOSTNAME)
		66
		67		# generate seed image
		68		self._generate_seed_image()
		69
		70		# extract kernel and initrd
		71		self._extract_initrd_and_kernel()
		72
		73		# deal with backing store
		74		self._create_local_disk()
		75
		76		def _create_dirs(self):
		77		if not os.path.isdir(self.path):
		78
		79		log.debug("Creating instance directories")
		80		os.makedirs(self.path)
		81		os.makedirs(self.meta_path)
		82
		83		def _create_user_data(self, password, overwrite=False, atomic=False):
		84		"""Save the right password to the 'user-data' file needed to
		85		emulate cloud-init. Default username on cloud images is "fedora"
		86
		87		Will not overwrite an existing user-data file unless
		88		the overwrite kwarg is set to True."""
		89
		90		if atomic:
		91		file_data = config_data.ATOMIC_USER_DATA % password
		92
		93		else:
		94		file_data = config_data.USER_DATA % password
		95
		96		data_path = '{}/meta/user-data'.format(self.path)
		97
		98		if (os.path.isfile(data_path) and overwrite) or not os.path.isfile(data_path):
		99		with open(data_path, 'w') as user_file:
		100		user_file.write(file_data)
		101		log.debug("Generated user-data for instance {}".format(self.name))
		102		else:
		103		log.debug("user-data file already exists for instance {}. Not"\
		104		" regerating.".format(self.name))
		105
		106
		107		def _create_meta_data(self, hostname, overwrite=False):
		108		"""Save the required hostname data to the 'meta-data' file needed to
		109		emulate cloud-init.
		110
		111		Will not overwrite an existing user-data file unless
		112		the overwrite kwarg is set to True."""
		113
		114		file_data = config_data.META_DATA % hostname
		115
		116		meta_path = "{}/meta-data".format(self.meta_path)
		117		if (os.path.isfile(meta_path) and overwrite) or not os.path.isfile(meta_path):
		118		with open(meta_path, 'w') as meta_data_file:
		119		meta_data_file.write(file_data)
		120
		121		log.debug("Generated meta-data for instance {}".format(self.name))
		122		else:
		123		log.debug("meta-data file already exists for instance {}. Not"\
		124		" regerating.".format(self.name))
		125
		126		def _generate_seed_image(self):
		127		"""Create a virtual filesystem needed for boot with virt-make-fs on a
		128		given path (it should probably be somewhere in '/tmp'."""
		129
		130		log.debug("creating seed image {}".format(self.seed_path))
		131
		132		make_image = subprocess.call(['virt-make-fs',
		133		'--type=msdos',
		134		'--label=cidata',
		135		self.meta_path,
		136		self.seed_path])
		137
		138		# Check the subprocess.call return value for success
		139		if make_image == 0:
		140		log.info("Seed image generated successfully")
		141		else:
		142		log.error("Seed image generation failed. Exiting")
		143		raise TestCloudInstanceError("Failure during seed image generation")
		144
		145		def _extract_initrd_and_kernel(self):
		146		"""Download the necessary kernel and initrd for booting a specified
		147		cloud image."""
		148
		149		# still need to figure out if the image needs to be copied from
		150		# cache for each instance
		151		# for now, assuming that it doesn't
		152
		153		log.info("extracting kernel and initrd from {}".format(self.image.local_path))
		154		subprocess.call(['virt-builder', '--get-kernel',
		155		self.image.local_path],
		156		cwd=self.path)
		157
		158		self.kernel = glob.glob("%s/vmlinuz" % self.path)[0]
		159		self.initrd = glob.glob("%s/initramfs" % self.path)[0]
		160
		161		if self.kernel is None or self.initrd is None:
		162		raise IndexError("Unable to find kernel or initrd, did they " +
		163		"download?")
		164		sys.exit(1)
		165
		166
		167		def _create_local_disk(self):
		168		"""Create a instance using the backing store provided by Image."""
		169
		170		subprocess.call(['qemu-img',
		171		'create',
		172		'-f',
		173		'qcow2',
		174		'-b',
		175		self.image.local_path,
		176		self.local_disk
		177		])
		178
		179
		180		def spawn_vm(self, expand_disk=False):
		181		"""Boot the cloud image redirecting local port 8888 to 80 on the vm as
		182		well as local port 2222 to 22 on the vm so http and ssh can be
		183		accessed.
		184
		185		Pass True to expand_disk if booting a fresh atomic image or you want to
		186		grow the disk size for some other reason at boot.
		187
		188		"""
		189
		190		boot_args = ['/usr/bin/virt-install',
		191		'--connect',
		192		'qemu:///system',
		193		'--import',
		194		'-n',
		195		self.name,
		196		'-r',
		197		str(self.ram),
		198		'--os-type=linux', # This should be configurable later
		199		'--disk',
		200		'{},device=disk,bus=virtio,format=qcow2'.format(
		201		self.local_disk),
		202		'--disk',
		203		'{},device=disk,bus=virtio'.format(self.seed_path),
		204		]
		205
		206		# Extend with the customizations from the config_data file
		207		boot_args.extend(config_data.CMD_LINE_ARGS)
		208
		209		# if expand_disk:
		210		# self.expand_qcow()
		211		#
		212		# if not self.atomic:
		213		# self.download_initrd_and_kernel()
		214		#
		215		# boot_args.extend(['--boot',
		216		# 'kernel={0},initrd={1},kernel_args={2}'.format(
		217		# self.kernel,
		218		# self.initrd,
		219		# '"root=/dev/vda1 ro ds=nocloud-net"'),
		220		# ])
		221		#
		222		if self.graphics:
		223		boot_args.extend(['--noautoconsole'])
		224
		225		if self.vnc:
		226		boot_args.extend(['-vnc', '0.0.0.0:1'])
		227
		228		vm = subprocess.Popen(boot_args)
		229
		230		log.info("Successfully booted your local cloud image!")
		231		log.info("PID: %d" % vm.pid)
		232
		233		return vm
		234
		235
		236
		237		def exists(self):
		238		"""Check to see if this instance already exists."""
		239
		240		pass
		241
		242		def expand_qcow(self, size="+10G"):
		243		"""Expand the storage for a qcow image. Currently only used for Atomic
		244		Hosts."""
		245
		246		log.info("expanding qcow2 image {}".format(self.image_path))
		247		subprocess.call(['qemu-img',
		248		'resize',
		249		self.image_path,
		250		size])
		251
		252		log.info("Resized image for Atomic testing...")
		253		return
		254
		255
		256		def set_seed(self, path):
		257		"""Set the seed image for the instance."""
		258		self.seed = path
		259
		260
		261		def boot(self):
		262		"""Boot an already spawned instance."""
		263
		264		subprocess.Popen(['virsh',
		265		'start',
		266		self.name
		267		])
		268
		269		def selfdestruct(self):
		270		"""Remove an instance from virsh."""
		271
		272		for cmd in ['destroy', 'undefine']:
		273		subprocess.Popen(['virsh',
		274		cmd,
		275		self.name
		276		])
		277

View Options

testCloud/libtestcloud.py

This file was deleted.

This file was completely deleted. Show File Contents

View Options

testCloud/util.py

1	#!/usr/bin/env python	1	#!/usr/bin/env python
2	# -- coding: utf-8 --	2	# -- coding: utf-8 --
3	# Copyright 2015, Red Hat, Inc.	3	# Copyright 2015, Red Hat, Inc.
4	# License: GPL-2.0+ <http://spdx.org/licenses/GPL-2.0+>	4	# License: GPL-2.0+ <http://spdx.org/licenses/GPL-2.0+>
5	# See the LICENSE file for more details on Licensing	5	# See the LICENSE file for more details on Licensing
6		6
7	"""	7	"""
8	This module contains helper functions for the housekeeping tasks of testCloud.	8	This module contains helper functions for the housekeeping tasks of testCloud.
9	"""	9	"""
10		10
11	import os	11	import os
12	import shutil	12	import shutil
13	import glob	13	import glob
14	import subprocess	14	import subprocess
15	import libvirt	15	import logging
16		16
		17	import libvirt
17	import xml.etree.ElementTree as ET	18	import xml.etree.ElementTree as ET
18		19
19	from . import config	20	from . import config
20	from .libtestcloud import log
21
22		21
		22	log = logging.getLogger('testCloud.util')
23	config_data = config.get_config()	23	config_data = config.get_config()
24		24
25	def create_user_data(path, password, overwrite=False, atomic=False):
26	"""Save the right password to the 'user-data' file needed to
27	emulate cloud-init. Default username on cloud images is "fedora"
28
29	Will not overwrite an existing user-data file unless
30	the overwrite kwarg is set to True."""
31
32	if atomic:
33	file_data = config_data.ATOMIC_USER_DATA % password
34
35	else:
36	file_data = config_data.USER_DATA % password
37
38	if os.path.isfile(path + '/meta/user-data'):
39	if overwrite:
40
41	with open(path + '/meta/user-data', 'w') as user_file:
42	user_file.write(file_data)
43
44	return "user-data file generated."
45	else:
46	return "user-data file already exists"
47
48	with open(path + '/meta/user-data', 'w') as user_file:
49	user_file.write(file_data)
50
51	return "user-data file generated."
52
53
54	def create_meta_data(path, hostname, overwrite=False):
55	"""Save the required hostname data to the 'meta-data' file needed to
56	emulate cloud-init.
57
58	Will not overwrite an existing user-data file unless
59	the overwrite kwarg is set to True."""
60
61	file_data = config_data.META_DATA % hostname
62
63	if os.path.isfile(path + '/meta/meta-data'):
64	if overwrite:
65
66	with open(path + '/meta/meta-data', 'w') as meta_data_file:
67	meta_data_file.write(file_data)
68
69	return "meta-data file generated."
70	else:
71	return "meta-data file already exists"
72
73	with open(path + '/meta/meta-data', 'w') as meta_data_file:
74	meta_data_file.write(file_data)
75
76	return "meta-data file generated."
77
78		25
79	def create_dirs():	26	def create_dirs():
80	"""Create the dirs in the download dir we need to store things."""	27	"""Create the dirs in the download dir we need to store things."""
81	os.makedirs(config_data.LOCAL_DOWNLOAD_DIR + 'testCloud/meta')	28	os.makedirs(config_data.LOCAL_DOWNLOAD_DIR + 'testCloud/meta')
82	if not os.path.exists(config_data.PRISTINE):	29	if not os.path.exists(config_data.PRISTINE):
83	os.makedirs(config_data.PRISTINE)	30	os.makedirs(config_data.PRISTINE)
84	log.debug("Created image store: {0}".format(config_data.PRISTINE))	31	log.debug("Created image store: {0}".format(config_data.PRISTINE))
85	return "Created tmp directories."	32	return "Created tmp directories."
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

Reworking paths to allow non-root usage and support multiple instances. Fixes T483ClosedPublicActions

Details

Diff Detail

Revision Contents

Diff 1011

README.rst

conf/settings-example.py

test/test_config.py

test/test_image.py

test/test_instance.py

testCloud/cli.py

testCloud/config.py

testCloud/exceptions.py

testCloud/image.py

testCloud/instance.py

testCloud/libtestcloud.py

testCloud/util.py

Reworking paths to allow non-root usage and support multiple instances. Fixes T483
ClosedPublic
Actions