def test_create_cluster_storage(self):
# default storage path
configurator = Configurator(self.config)
storage = configurator.create_cluster_storage()
default_storage = configurator.general_conf['storage']
self.assertEqual(storage._storage_dir, default_storage)
# custom storage path
path = "/tmp"
configurator = Configurator(self.config, storage_path=path)
storage = configurator.create_cluster_storage()
self.assertEqual(storage._storage_dir, path)
def get_cluster(self, cloud_provider=None, config=None, nodes=None):
if not cloud_provider:
cloud_provider = BotoCloudProvider("https://hobbes.gc3.uzh.ch/",
"nova", "a-key", "s-key")
if not config:
config = Configuration().get_config(self.path)
setup = Mock()
configurator = Configurator(config)
conf_login = configurator.cluster_conf['mycluster']['login']
repository = PickleRepository(self.storage_path)
cluster = Cluster(
name="mycluster",
cloud_provider=cloud_provider,
setup_provider=setup,
repository=repository,
user_key_name=conf_login['user_key_name'],
user_key_public=conf_login['user_key_public'],
user_key_private=conf_login['user_key_private'],
)
if not nodes:
nodes = {"compute": 2, "frontend": 1}
for kind, num in nodes.iteritems():
conf_kind = configurator.cluster_conf['mycluster']['nodes'][kind]
cluster.add_nodes(kind, num, conf_kind['image_id'],
conf_login['image_user'], conf_kind['flavor'],
conf_kind['security_group'])
return cluster
def test_create_node(self):
configurator = Configurator(self.config)
node = configurator.create_node("mycluster", "compute", None, "test-1")
self.assertTrue(type(node) is Node)
self.assertEqual(node.name, "test-1")
self.assertEqual(node.type, "compute")
self.assertEqual(node._cloud_provider, None)
pub_key = self.config['mycluster']['login']['user_key_public']
self.assertEqual(node.user_key_public, pub_key)
prv_key = self.config['mycluster']['login']['user_key_private']
self.assertEqual(node.user_key_private, prv_key)
key_name = self.config['mycluster']['login']['user_key_name']
self.assertEqual(node.user_key_name, key_name)
usr = self.config['mycluster']['login']['image_user']
self.assertEqual(node.image_user, usr)
nodes = self.config['mycluster']['nodes']
sec_group = nodes['compute']['security_group']
self.assertEqual(node.security_group, sec_group)
image = self.config['mycluster']['nodes']['compute']['image_id']
self.assertEqual(node.image, image)
flavor = self.config['mycluster']['nodes']['compute']['flavor']
self.assertEqual(node.flavor, flavor)
self.assertEqual(node.image_userdata, '')
def test_load_cluster(self):
# test without storage file
storage_path = tempfile.mkdtemp()
configurator = Configurator(self.config, storage_path=storage_path)
self.assertRaises(ClusterNotFound,
configurator.load_cluster, "mycluster")
shutil.rmtree(storage_path)
def test_create_cluster_with_nodes_min(self):
cfg = self.config.copy()
cfg['mycluster']['cluster']['compute_nodes_min'] = 1
configurator = Configurator(cfg)
cconf = configurator.cluster_conf['mycluster']['cluster']
self.assertEqual(cconf['compute_nodes_min'], 1)
def test_create_cluster(self):
configurator = Configurator(self.config)
cluster = configurator.create_cluster("mycluster")
self.assertEqual(cluster.name, "mycluster")
self.assertTrue(type(cluster._cloud_provider) is BotoCloudProvider)
self.assertTrue(type(cluster._setup_provider) is AnsibleSetupProvider)
self.assertTrue("compute" in cluster.nodes)
self.assertTrue("frontend" in cluster.nodes)
self.assertTrue(len(cluster.nodes["compute"]) == 2)
self.assertTrue(len(cluster.nodes["frontend"]) == 1)
def get_cluster(self, cloud_provider=None, config=None, nodes=None):
if not cloud_provider:
cloud_provider = BotoCloudProvider("https://hobbes.gc3.uzh.ch/",
"nova", "a-key", "s-key")
if not config:
config = Configuration().get_config(self.path)
setup = Mock()
configurator = Configurator(config)
if not nodes:
nodes = {"compute": 2, "frontend": 1}
cluster = Cluster("mycluster", "mycluster", "hobbes", cloud_provider,
setup, nodes, configurator)
return cluster
def test_create_cloud_provider(self):
configurator = Configurator(self.config)
provider = configurator.create_cloud_provider("mycluster")
url = self.config['mycluster']['cloud']['ec2_url']
self.assertEqual(provider._url, url)
access_key = self.config['mycluster']['cloud']['ec2_access_key']
self.assertEqual(provider._access_key, access_key)
secret_key = self.config['mycluster']['cloud']['ec2_secret_key']
self.assertEqual(provider._secret_key, secret_key)
region = self.config['mycluster']['cloud']['ec2_region']
self.assertEqual(provider._region_name, region)
def test_setup_provider_using_environment(self):
config = copy.deepcopy(self.config)
configurator = Configurator(config)
# Save current variable, modify it and check if it's correctly read
SAVEDUSERNAME = os.getenv('OS_USERNAME')
os.environ['OS_USERNAME'] = '******'
provider = configurator.create_cloud_provider("os-cluster")
try:
self.assertEqual(provider._os_username, 'newusername')
except:
if SAVEDUSERNAME:
os.environ['OS_USERNAME'] = SAVEDUSERNAME
else:
del os.environ['OS_USERNAME']
raise
def test_dump_cluster(self):
"""
Dump cluster to json
"""
storage = self.get_cluster_storage()
configurator = Configurator(Configuration().get_config(self.path))
nodes = {"compute": 2, "frontend": 1}
cluster = Cluster("mycluster", "cluster_name", "hobbes", MagicMock(),
MagicMock(), nodes, configurator)
instance_id = "test-id"
ip_public = "127.0.0.1"
ip_private = "127.0.0.2"
for node in cluster.get_all_nodes():
node.instance_id = instance_id
node.ip_public = ip_public
node.ip_private = ip_private
storage.dump_cluster(cluster)
dump = os.path.join(self.storage_path, "cluster_name.json")
f = open(dump, "r")
content = f.read()
expected = """
{"compute_nodes": 2, "nodes":
[{"instance_id": "test-id", "ip_public": "127.0.0.1",
"type": "compute", "name": "compute001",
"ip_private": "127.0.0.2"},
{"instance_id": "test-id", "ip_public": "127.0.0.1",
"type": "compute", "name": "compute002",
"ip_private": "127.0.0.2"},
{"instance_id": "test-id", "ip_public": "127.0.0.1",
"type": "frontend", "name": "frontend001",
"ip_private": "127.0.0.2"}],
"frontend_nodes": 1, "name": "cluster_name",
"template": "mycluster"}"""
self.assertEqual(json.loads(content), json.loads(expected))
os.unlink(dump)
def test_create_setup_provider(self):
configurator = Configurator(self.config)
provider = configurator.create_setup_provider("mycluster")
self.assertTrue(type(provider) is AnsibleSetupProvider)
prv_key = self.config['mycluster']['login']['user_key_private']
self.assertEqual(provider._private_key_file, prv_key)
usr = self.config['mycluster']['login']['image_user']
self.assertEqual(provider._remote_user, usr)
usr_sudo = self.config['mycluster']['login']['image_user_sudo']
self.assertEqual(provider._sudo_user, usr_sudo)
sudo = self.config['mycluster']['login']['image_sudo']
self.assertEqual(provider._sudo, sudo)
pb = self.config['mycluster']['setup']['playbook_path']
self.assertEqual(provider._playbook_path, pb)
def test_create_setup_provider(self):
configurator = Configurator(self.config)
provider = configurator.create_setup_provider("mycluster")
self.assertTrue(type(provider) is AnsibleSetupProvider)
conf = self.config['mycluster']['setup']
groups = dict((k[:-7], v.split(',')) for k, v
in conf.items() if k.endswith('_groups'))
self.assertEqual(groups, provider.groups)
playbook_path = os.path.join(sys.prefix,
'share/elasticluster/providers/ansible-playbooks', 'site.yml')
self.assertEqual(playbook_path, provider._playbook_path)
storage_path = configurator.general_conf['storage']
self.assertEqual(provider._storage_path, storage_path)
usr_sudo = self.config['mycluster']['login']['image_user_sudo']
self.assertEqual(provider._sudo_user, usr_sudo)
sudo = self.config['mycluster']['login']['image_sudo']
self.assertEqual(provider._sudo, sudo)
def test_storage_type(self):
configurator = Configurator(self.config)
repo = configurator.create_repository()
