def test_change_package(self, *args):
"""
AC-1003
If new package lacks kube_types, that used in user's pods,
then forbid this change.
"""
user = self.user
url = self.item_url(self.user.id)
package0 = user.package
package1 = Package(id=1,
name='New package',
first_deposit=0,
currency='USD',
period='hour',
prefix='$',
suffix=' USD')
kube0, kube1, kube2 = Kube.public_kubes().all()
# new package allows only standard kube
PackageKube(package=package1, kube=kube0, kube_price=0)
db.session.commit()
# change package: user still doesn't have pods
data = {'package': package1.name}
response = self.admin_open(url=url, method='PUT', json=data)
self.assert200(response)
# add pod with kube type that exists in both packages (Standard kube)
pod = Pod(id=str(uuid4()),
name='test_change_package1',
owner_id=user.id,
kube_id=0,
config='')
db.session.add(pod)
db.session.commit()
# change package: both packages have this kube_type
data = {'package': package0.name}
self.assert200(self.admin_open(url=url, method='PUT', json=data))
# add pod with kube type that exists only in current package
pod = Pod(id=str(uuid4()),
name='test_change_package2',
owner_id=user.id,
kube_id=1,
config='')
db.session.add(pod)
db.session.commit()
# change package: new package doesn't have kube_type of some of user's
# pods
data = {'package': package1.name}
self.assert400(self.admin_open(url=url, method='PUT', json=data))
def test_drive_can_be_deleted(self):
"""Test LocalStorage.drive_can_be_deleted method."""
user, _ = self.fixtures.user_fixtures()
pd = PersistentDisk(name='q', owner_id=user.id, size=1)
db.session.add(pd)
db.session.commit()
flag, reason = pstorage.LocalStorage.drive_can_be_deleted(pd.id)
self.assertTrue(flag)
self.assertIsNone(reason)
pod_id = str(uuid.uuid4())
pdname = 'somename1'
pod = Pod(id=pod_id,
name='somename',
owner_id=user.id,
kube_id=Kube.get_default_kube_type(),
config=json.dumps({
"volumes_public": [{
"persistentDisk": {
"pdSize": 1,
"pdName": pdname
},
}]
}))
db.session.add(pod)
db.session.commit()
flag, reason = pstorage.LocalStorage.drive_can_be_deleted(pd.id)
self.assertTrue(flag)
self.assertIsNone(reason)
pd = PersistentDisk(name=pdname, owner_id=user.id, size=1)
db.session.add(pd)
db.session.commit()
flag, reason = pstorage.LocalStorage.drive_can_be_deleted(pd.id)
self.assertFalse(flag)
self.assertIsNotNone(reason)
# delete pod, drive must became deletable
pod.status = 'deleted'
db.session.query(Pod).update({Pod.status: 'deleted'},
synchronize_session=False)
db.session.commit()
flag, reason = pstorage.LocalStorage.drive_can_be_deleted(pd.id)
self.assertTrue(flag)
self.assertIsNone(reason)
def _add_public_access_type(upd):
upd.print_log('Update pod configs')
pods = Pod.all()
for pod in pods:
db_config = pod.get_dbconfig()
pod.set_dbconfig(db_config, save=False)
if 'public_access_type' in db_config:
continue
elif (db_config.get('public_ip', None)
or db_config.get('public_ip_before_freed', None)):
db_config['public_access_type'] = PublicAccessType.PUBLIC_IP
elif db_config.get('public_aws', None):
db_config['public_access_type'] = PublicAccessType.PUBLIC_AWS
elif db_config.get('domain', None):
db_config['public_access_type'] = PublicAccessType.DOMAIN
if not db_config.get('base_domain', None):
domain = db_config['domain']
base_domain = BaseDomain.query.filter_by(name=domain).first()
if base_domain:
db_config['base_domain'] = domain
db_config.pop('domain')
else:
sub_domain_part, base_domain_part = domain.split('.', 1)
base_domain = BaseDomain.query.filter_by(
name=base_domain_part).first()
if base_domain is None:
raise DomainNotFound(
"Can't find BaseDomain for requested domain {0}".
format(domain))
pod_domain = PodDomain.query.filter_by(
name=sub_domain_part,
domain_id=base_domain.id,
pod_id=pod.id).first()
if not pod_domain:
raise DomainNotFound(
"Can't find PodDomain for requested domain {0}".
format(domain))
db_config['base_domain'] = base_domain.name
db_config['domain'] = domain
else:
db_config['public_access_type'] = PublicAccessType.PUBLIC_IP
pod.set_dbconfig(db_config, save=False)
def _check_if_pod_exists(pod_id):
user = KubeUtils.get_current_user()
try:
pod = Pod.filter(Pod.owner_id == user.id, Pod.id == pod_id).first()
if pod is None:
raise PodNotFound
except DataError:
# pod_id is not uuid
raise PodNotFound
def test_update_pods_volumes(self):
"""Test pstorage.update_pods_volumes function"""
user, _ = self.fixtures.user_fixtures()
old_drive_name = 'qq11'
new_drive_name = 'ww22'
pdname = 'qwerty1243'
pod_id = str(uuid.uuid4())
storage_prefix = pstorage.NODE_LOCAL_STORAGE_PREFIX
pod = Pod(id=pod_id,
name='somename',
owner_id=user.id,
kube_id=Kube.get_default_kube_type(),
config=json.dumps({
"volumes": [{
"hostPath": {
"path": storage_prefix + '/' + old_drive_name
},
"name": "var-qqq7824431125",
"annotation": {
"localStorage": {
"path":
storage_prefix + '/' + old_drive_name,
"size": 1
}
}
}],
"volumes_public": [{
"persistentDisk": {
"pdSize": 1,
"pdName": pdname
},
"name": "var-qqq7824431125"
}]
}))
db.session.add(pod)
new_pd = PersistentDisk(name=pdname,
drive_name=new_drive_name,
owner_id=user.id,
size=1)
db.session.add(new_pd)
db.session.commit()
pstorage.update_pods_volumes(new_pd)
pods = db.session.query(Pod).all()
self.assertTrue(len(pods), 1)
new_pod = pods[0]
config = new_pod.get_dbconfig()
self.assertEqual(len(config['volumes']), len(config['volumes_public']))
self.assertEqual(len(config['volumes']), 1)
new_drive_path = storage_prefix + '/' + new_drive_name
self.assertEqual(config['volumes'][0]['hostPath']['path'],
new_drive_path)
self.assertEqual(
config['volumes'][0]['annotation']['localStorage']['path'],
new_drive_path)
self.assertEqual(
config['volumes_public'][0]['persistentDisk']['pdName'], pdname)
def _recreate_ingress_pod_if_needed():
kd_user = User.get_internal()
ingress_pod = Pod.filter_by(name=KUBERDOCK_INGRESS_POD_NAME,
owner=kd_user).first()
if ingress_pod or BaseDomain.query.first():
PodCollection(kd_user).delete(ingress_pod.id, force=True)
default_backend_pod = Pod.filter_by(name=KUBERDOCK_BACKEND_POD_NAME,
owner=kd_user).first()
if not default_backend_pod:
raise Exception(
'Nginx ingress controller pod exists, but default backend pod '
'is not found. Something wrong. Please contact support to get '
'help.')
PodCollection(kd_user).delete(default_backend_pod.id, force=True)
c = ConfigMapClient(KubeQuery())
try:
c.delete(name=KUBERDOCK_INGRESS_CONFIG_MAP_NAME,
namespace=KUBERDOCK_INGRESS_CONFIG_MAP_NAMESPACE)
except ConfigMapNotFound:
pass
sleep(30) # TODO: Workaround. Remove it when AC-5470 will be fixed
ingress.prepare_ip_sharing()
def setUp(self):
# create test data
self.another_user, _ = fixtures.user_fixtures(
username='******', email='*****@*****.**')
config = '{"containers":[{"kubes":1}]}'
self.ips = [(Pod(id=str(uuid4()), owner_id=self.user.id, name='pod1',
kube_id=0, config=config).save(), u'192.168.43.132'),
(Pod(id=str(uuid4()), owner_id=self.user.id, name='pod2',
kube_id=0, config=config).save(), u'192.168.43.133'),
(Pod(id=str(uuid4()), owner_id=self.another_user.id,
name='pod3',
kube_id=0, config=config).save(), u'192.168.43.134')]
for pod, ip in self.ips:
IpState.start(pod.id, int(ip_address(ip)))
self.pds = [(self.user.id, 'first_disk', 2),
(self.user.id, 'second_disk', 16),
(self.another_user.id, 'third_disk', 3)]
for user_id, name, size in self.pds:
PersistentDiskState.start(user_id, name, size)
sleep(1)
IpState.end(self.ips[0][0].id, int(ip_address(self.ips[0][1])))
PersistentDiskState.end(self.pds[0][0], self.pds[0][1])
self.stop_date = datetime.utcnow()
def upgrade(upd, with_testing, *args, **kwargs):
upd.print_log('Update dns pod...')
local(
'etcd-ca --depot-path /root/.etcd-ca new-cert --ip "10.254.0.10" --passphrase "" etcd-dns'
)
local('etcd-ca --depot-path /root/.etcd-ca sign --passphrase "" etcd-dns')
local(
'etcd-ca --depot-path /root/.etcd-ca export etcd-dns --insecure --passphrase "" | tar -xf -'
)
local('mv etcd-dns.crt /etc/pki/etcd/etcd-dns.crt')
local('mv etcd-dns.key.insecure /etc/pki/etcd/etcd-dns.key')
user = User.filter_by(username=KUBERDOCK_INTERNAL_USER).one()
dns_pod = Pod.filter_by(name='kuberdock-dns', owner=user).first()
if dns_pod:
PodCollection(user).delete(dns_pod.id, force=True)
dns_config = get_dns_pod_config()
check_internal_pod_data(dns_config, user)
dns_pod = PodCollection(user).add(dns_config, skip_check=True)
PodCollection(user).update(dns_pod['id'], {'command': 'start'})
def test_execute_es_query(self, es_mock):
"""Test elasticsearch_utils.execute_es_query function."""
# Add two log pods config + two approprate nodes
internal_user = User.get_internal()
pod_id1 = str(uuid4())
service1 = 'srv1'
namespace1 = 'ns1'
pod_id2 = str(uuid4())
service2 = 'srv2'
namespace2 = 'ns2'
host1 = 'h1'
host2 = 'h2'
kube_id = Kube.get_default_kube_type()
pod1 = Pod(id=pod_id1,
name=get_kuberdock_logs_pod_name(host1),
owner_id=internal_user.id,
kube_id=kube_id,
config=json.dumps({
"service": service1,
"namespace": namespace1
}),
status='RUNNING')
pod2 = Pod(id=pod_id2,
name=get_kuberdock_logs_pod_name(host2),
owner_id=internal_user.id,
kube_id=kube_id,
config=json.dumps({
"service": service2,
"namespace": namespace2
}),
status='RUNNING')
db.session.add_all([pod1, pod2])
db.session.commit()
node1 = Node(ip='123.123.123',
hostname=host1,
kube_id=kube_id,
state='completed',
upgrade_status='applied')
node2 = Node(ip='123.123.124',
hostname=host2,
kube_id=kube_id,
state='completed',
upgrade_status='applied')
db.session.add_all([node1, node2])
db.session.commit()
size = 123
index = '1234qwerty'
query = None
sort = None
search_result = {'hits': {'total': 333, 'hits': [1, 2, 3]}}
search_mock = es_mock.return_value.search
search_mock.return_value = search_result
res = elasticsearch_utils.execute_es_query(index, query, size, sort)
self.assertEqual(
res, {
'total': search_result['hits']['total'],
'hits': search_result['hits']['hits'],
})
prefix1 = elasticsearch_utils.K8S_PROXY_PREFIX + \
'/namespaces/' + namespace1 + '/services/' + service1 + ':9200/'
prefix2 = elasticsearch_utils.K8S_PROXY_PREFIX + \
'/namespaces/' + namespace2 + '/services/' + service2 + ':9200/'
es_mock.assert_called_once_with([
{
'host': KUBE_API_HOST,
'port': KUBE_API_PORT,
'url_prefix': prefix1,
},
{
'host': KUBE_API_HOST,
'port': KUBE_API_PORT,
'url_prefix': prefix2,
},
])
search_mock.assert_called_once_with(index=index, body={'size': size})
query = {'a': 1}
sort = {'b': 2}
elasticsearch_utils.execute_es_query(index, query, size, sort)
search_mock.assert_called_with(index=index,
body={
'size': size,
'sort': sort,
'query': query
})
search_mock.side_effect = RequestException('!!!')
with self.assertRaises(elasticsearch_utils.LogsError):
elasticsearch_utils.execute_es_query(index, query, size, sort)
def test_get_drives_from_db(self):
"""Test PersistentStorage._get_drives_from_db"""
user, _ = self.fixtures.user_fixtures()
pd1 = PersistentDisk(name='q', owner_id=user.id, size=1)
pd2 = PersistentDisk(name='q1', owner_id=user.id, size=2)
pd3 = PersistentDisk(name='q1', owner_id=1, size=2)
db.session.add_all([pd1, pd2, pd3])
db.session.commit()
ps = pstorage.PersistentStorage()
drives = ps._get_drives_from_db()
self.assertEqual(len(drives), 3)
self.assertEqual([[], [], []], [item['linkedPods'] for item in drives])
ps = pstorage.PersistentStorage()
drives = ps._get_drives_from_db(user_id=user.id)
self.assertEqual(len(drives), 2)
self.assertEqual([[], []], [item['linkedPods'] for item in drives])
self.assertEqual({user.id: user.username},
{item['owner_id']: item['owner']
for item in drives})
self.assertEqual({'q1', 'q'}, {item['name'] for item in drives})
self.assertEqual([False, False], [item['in_use'] for item in drives])
self.assertEqual([False, False],
[item['forbidDeletion'] for item in drives])
pod_id = str(uuid.uuid4())
pod_name = 'somename1'
pod = Pod(id=pod_id,
name=pod_name,
owner_id=user.id,
kube_id=Kube.get_default_kube_type(),
config=json.dumps({
"volumes_public": [{
"persistentDisk": {
"pdSize": 1,
"pdName": 'q'
},
}]
}))
db.session.add(pod)
db.session.commit()
ps = pstorage.PersistentStorage()
drives = ps._get_drives_from_db(user_id=user.id)
self.assertEqual(len(drives), 2)
with_pods = None
without_pods = None
for drive in drives:
if drive['name'] == 'q':
with_pods = drive
else:
without_pods = drive
self.assertEqual(with_pods['linkedPods'], [{
'podId': pod_id,
'name': pod_name
}])
self.assertEqual(without_pods['linkedPods'], [])
self.assertEqual([False, False], [item['in_use'] for item in drives])
self.assertEqual([False, False],
[item['forbidDeletion'] for item in drives])
pd1.pod_id = pod.id
db.session.commit()
drives = ps._get_drives_from_db(user_id=user.id)
pd1_data = (item for item in drives if item['id'] == pd1.id).next()
pd2_data = (item for item in drives if item['id'] == pd2.id).next()
self.assertEqual(True, pd1_data['in_use'])
self.assertEqual(False, pd2_data['in_use'])
self.assertEqual(True, pd1_data['forbidDeletion'])
self.assertEqual(False, pd2_data['forbidDeletion'])