def test_id_generation(self, provisioner):
provisioner.save(check_status=False)
empty = Cluster(provisioner._object_namespace,
name='test',
provisioner=provisioner)
empty.save()
def __init__(self, test_provisioner=None, test_user=None):
test_user = test_user if test_user is not None else UserFixture()
if not test_provisioner:
test_provisioner = ProvisionerFixture(test_user=test_user)
self.test_provisioner = test_provisioner
owner = test_user.obj
provisioner = self.test_provisioner.obj
provisioner.state = config.get('PROVISIONER_OK_STATE')
provisioner.save(check_status=False)
_uuid = uuid.uuid4()
create_kwargs = {
'id': _uuid,
'name': 'Name for cluster {}'.format(_uuid),
'provisioner': provisioner,
'state': config.get('CLUSTER_UNKNOWN_STATE'),
'kubeconfig': yaml.load(open('kubeconfig_localhost', 'r').read()),
'created_at': datetime.datetime.utcnow().replace(microsecond=0),
'owner': owner,
'metadata': {}
}
self.obj = Cluster.create(owner.namespace, **create_kwargs)
def test_create_over_api(self):
"""Verify Cluster is created over API and kubeconfig is set"""
url = url_for('api.cluster_list')
data = self.create_kwargs_cluster
data['provisioner'] = 'Provisioner:{}'.format(data['provisioner'].id)
data['owner'] = 'User:{}'.format(data['owner'].id)
# create
response = self.client.post(url,
data=json.dumps(data),
headers=self.auth_header,
content_type='application/json')
assert response.status_code == 200
# load
cluster_id = response.json['id']
obj = Cluster.load(self.namespace, cluster_id)
validation, _ = obj.validate()
assert validation
# check parameters
assert obj.kubeconfig == data['kubeconfig']
return obj
def cluster():
create_kwargs = {
'name': 'mycluster',
'provisioner': 'Jenkins',
'state': 'failed',
}
return Cluster.create(**create_kwargs)
def test_list_without_objects(self, cluster):
cluster.save()
loaded = Cluster.list(cluster._object_namespace, return_objects=False)
assert str(cluster.id) in loaded
for o_name, o in loaded.items():
assert o is None
def test_load(self, cluster):
get_id = cluster.id
cluster.save()
loaded = Cluster.load(get_id)
assert loaded == cluster
assert hasattr(loaded, '_key'), 'Loaded object is missing _key'
def setup(self):
_user = user()
create_kwargs_provisioner = {
'name': 'Testing manual',
'engine': 'kqueen.engines.ManualEngine',
'parameters': PROVISIONER_PARAMETERS,
'owner': _user
}
prov = Provisioner(_user.namespace, **create_kwargs_provisioner)
prov.save(check_status=False)
self.create_kwargs_cluster = {
'name': 'Testing cluster for manual provisioner',
'provisioner': prov,
'state': 'deployed',
'kubeconfig': KUBECONFIG,
'metadata': CLUSTER_METADATA,
'owner': _user
}
self.cluster = Cluster.create(_user.namespace,
**self.create_kwargs_cluster)
self.engine = ManualEngine(cluster=self.cluster)
# client setup
self.auth_header = auth_header(self.client)
self.namespace = self.auth_header['X-Test-Namespace']
def test_load(self, cluster):
cluster.save()
get_id = cluster.id
loaded = Cluster.load(cluster._object_namespace, get_id)
assert loaded.get_dict(True) == cluster.get_dict(True)
assert hasattr(loaded, '_key'), 'Loaded object is missing _key'
def cluster(self):
_uuid = uuid.uuid4()
create_kwargs = {
'name': 'mycluster',
'color': 'red',
'id': _uuid,
}
return Cluster.create(**create_kwargs)
def cluster_list():
# TODO: implement native serialization
output = []
for cluster in list(Cluster.list(return_objects=True).values()):
output.append(cluster.get_dict())
return jsonify(output)
def cluster_detail(cluster_id):
# read uuid
try:
object_id = UUID(cluster_id, version=4)
except ValueError:
abort(404)
# load object
try:
obj = Cluster.load(object_id)
except NameError:
abort(404)
return jsonify(obj.get_dict())
def setup(self):
create_kwargs_provisioner = {
'name': 'Testing manual',
'engine': 'kqueen.engines.ManualEngine'
}
prov = Provisioner(**create_kwargs_provisioner)
prov.save(check_status=False)
create_kwargs_cluster = {
'name': 'Testing cluster for manual provisioner',
'provisioner': prov,
'state': 'deployed',
'kubeconfig': yaml.load(open('kubeconfig_localhost', 'r').read()),
}
self.cluster = Cluster.create(**create_kwargs_cluster)
self.engine = ManualEngine(cluster=self.cluster)
def cluster():
"""Create cluster with manual provisioner."""
_uuid = uuid.uuid4()
prov = Provisioner(
name='Fixtured provisioner',
engine='kqueen.engines.ManualEngine',
)
prov.save(check_status=False)
create_kwargs = {
'id': _uuid,
'name': 'Name for cluster {}'.format(_uuid),
'provisioner': prov,
'state': 'deployed',
'kubeconfig': yaml.load(open('kubeconfig_localhost', 'r').read()),
}
return Cluster.create(**create_kwargs)
def cluster():
"""Create cluster with manual provisioner."""
_uuid = uuid.uuid4()
_user = user()
prov = Provisioner(_user.namespace,
name='Fixtured provisioner',
engine='kqueen.engines.ManualEngine',
owner=_user)
prov.save(check_status=False)
create_kwargs = {
'id': _uuid,
'name': 'Name for cluster {}'.format(_uuid),
'provisioner': prov,
'state': config.get('CLUSTER_UNKNOWN_STATE'),
'kubeconfig': yaml.load(open('kubeconfig_localhost', 'r').read()),
'created_at': datetime.datetime.utcnow().replace(microsecond=0),
'owner': _user
}
return Cluster.create(_user.namespace, **create_kwargs)
def test_delete_remove_object(self):
obj = self.test_create_over_api()
obj.delete()
assert not Cluster.exists(self.namespace, obj.id)
def test_id_generation(self):
empty = Cluster()
empty.save()
engine='kqueen.engines.JenkinsEngine',
parameters={
'username': '******',
'password': '******'
}
)
provisioner.save(check_status=False)
except:
raise Exception('Adding AWS provisioner failed')
try:
cluster = Cluster(
id=uuid_jenkins,
name='AWS Calico SM 33',
state='OK',
provisioner=provisioner,
kubeconfig=yaml.load(requests.get(kubeconfig_url).text),
)
cluster.save()
except:
raise Exception('Adding AWS cluster failed')
# Local cluster
try:
provisioner = Provisioner(
id=uuid_provisioner_local,
name='Manual provisioner',
state='OK',
engine='kqueen.engines.ManualEngine',
def test_exists(self, cluster):
assert not Cluster.exists(cluster._object_namespace, cluster.id)
cluster.save()
assert Cluster.exists(cluster._object_namespace, cluster.id)
def test_list_with_objects(self, cluster):
cluster.save()
loaded = Cluster.list(cluster._object_namespace)
assert str(cluster.id) in loaded
def test_exists(self, cluster):
assert not Cluster.exists(cluster.id)
cluster.save()
assert Cluster.exists(cluster.id)
def test_kubeconfig_load_is_dict(self, cluster):
cluster.save()
loaded = Cluster.load(cluster._object_namespace, cluster.id)
assert isinstance(loaded.kubeconfig, dict), 'Loaded kubeconfig is not dict'
#!/usr/bin/env python3
from kqueen.server import create_app
from kqueen.models import Cluster
app = create_app()
with app.app_context():
cluster = Cluster.load('demoorg', 'c02d3b7c-d06e-11e7-973c-68f72873a109')
print(cluster)
print(cluster.get_dict())
print(cluster.engine)
print(cluster.provisioner.get_engine_cls())
# cluster.engine.provision()
print(cluster.engine.get_kubeconfig())
# cluster.engine.deprovision()
# GKE provisioner
try:
provisioner = Provisioner(user.namespace,
id=uuid_provisioner_gke,
name='Google Kubernetes engine',
state='OK',
engine='kqueen.engines.GceEngine',
created_at=datetime.utcnow())
provisioner.save(check_status=False)
except:
raise Exception('Adding GKE provisioner failed')
try:
cluster = Cluster(user.namespace,
id=uuid_gke,
state='OK',
name='GKE clustet, paused',
provisioner=provisioner,
created_at=datetime.utcnow())
cluster.save()
except:
raise Exception('Adding GKE provisioner failed')
# AKS provisioner
try:
provisioner = Provisioner(user.namespace,
id=uuid_provisioner_aks,
name='Azure Kubernetes Service',
state='OK',
engine='kqueen.engines.AksEngine',
created_at=datetime.utcnow())
provisioner.save(check_status=False)
#!/usr/bin/env python3
from kqueen.server import create_app
from kqueen.models import Cluster
app = create_app()
with app.app_context():
cluster = Cluster.load('demoorg', '9212695e-3aad-434d-ba26-3403481d37a1')
print(cluster)
print(cluster.get_dict())
print(cluster.engine)
print(cluster.provisioner.get_engine_cls())
cluster.engine.provision()
print(cluster.engine.get_kubeconfig())
