def zabbix_update_host_visible_name(instance_uuid):
instance = Instance.objects.get(uuid=instance_uuid)
try:
zabbix_client = ZabbixApiClient()
zabbix_client.update_host_visible_name(instance)
except ZabbixError as e:
# task does not have to fail if something is wrong with zabbix
logger.error('Zabbix host visible name update has failed %s' % e,
exc_info=1)
def update_instance_sla(sla_type):
if sla_type not in ('yearly', 'monthly'):
logger.error('Requested unknown SLA type: %s' % sla_type)
return
dt = datetime.datetime.now()
if sla_type == 'yearly':
period = dt.year
start_time = int(
datetime.datetime.strptime('01/01/%s' % dt.year,
'%d/%m/%Y').strftime("%s"))
end_time = int(
datetime.datetime.strptime('01/01/%s' % (dt.year + 1),
'%d/%m/%Y').strftime("%s"))
else: # it's a monthly SLA update
period = '%s-%s' % (dt.year, dt.month)
month_start = datetime.datetime.strptime(
'01/%s/%s' % (dt.month, dt.year), '%d/%m/%Y')
start_time = int(month_start.strftime("%s"))
end_time = int(add_months(month_start, 1).strftime("%s"))
instances = Instance.objects.exclude(state__in=[
Instance.States.DELETING,
Instance.States.PROVISIONING_SCHEDULED,
Instance.States.PROVISIONING,
])
zabbix_client = ZabbixApiClient()
for instance in instances:
try:
logger.debug(
'Updating %s SLAs for instance %s. Period: %s, start_time: %s, end_time: %s'
% (sla_type, instance, period, start_time, end_time))
current_sla, events = zabbix_client.get_current_service_sla(
instance, start_time=start_time, end_time=end_time)
entry, _ = InstanceSlaHistory.objects.get_or_create(
instance=instance, period=period)
entry.value = Decimal(current_sla)
entry.save()
# update connected events
for event in events:
event_state = 'U' if int(event['value']) == 0 else 'D'
entry.events.get_or_create(timestamp=int(event['timestamp']),
state=event_state)
except ZabbixError as e:
logger.warning(
'Zabbix error when updating current SLA values for %s. Reason: %s'
% (instance, e))
except Exception as e:
logger.warning(
'Failed to update current SLA values for %s. Reason: %s' %
(instance, e))
def create_host(cloud_project_membership, warn_if_exists=True):
if not ZABBIX_ENABLED:
return
try:
zabbix_client = ZabbixApiClient()
zabbix_client.create_host(cloud_project_membership,
warn_if_host_exists=warn_if_exists,
is_tenant=True)
except ZabbixError as e:
# task does not have to fail if something is wrong with zabbix
logger.error('Zabbix host creation flow has been broken %s' % e,
exc_info=1)
def zabbix_update_host_visible_name(instance_uuid, is_tenant=False):
if is_tenant:
host = CloudProjectMembership.objects.get(pk=instance_uuid)
else:
host = Instance.objects.get(uuid=instance_uuid)
try:
zabbix_client = ZabbixApiClient()
zabbix_client.update_host_visible_name(host, is_tenant)
except ZabbixError as e:
# task does not have to fail if something is wrong with zabbix
logger.error('Zabbix host visible name update has failed %s' % e,
exc_info=1)
def setUp(self):
self.zabbix_parameters = settings.NODECONDUCTOR['MONITORING']['ZABBIX']
self.api = get_mocked_zabbix_api()
self.zabbix_client = ZabbixApiClient()
self.zabbix_client.get_zabbix_api = Mock(return_value=self.api)
self.project = Mock()
self.project.name = 'test_project'
self.project.uuid = 'asdqwe1231232'
self.instance = Mock()
self.instance.uuid = 'qwedaqwedawqwqrt123sdasd123123'
self.instance.name = 'test_instance'
self.instance.cloud_project_membership.project = self.project
def get_stats(self, instance, start, end):
items = []
for item in self.validated_data['items']:
if item == 'memory_util' and instance.type == models.Instance.Services.PAAS:
items.append('memory_util_agent')
else:
items.append(item)
method = self.validated_data['method']
host = ZabbixApiClient().get_host_name(instance)
records = ZabbixDBClient().get_host_max_values(host, items, start, end, method=method)
results = []
for timestamp, item, value in records:
# XXX: Quick and dirty fix: zabbix presents percentage of free space(not utilized) for storage
if item in ('storage_root_util', 'storage_data_util'):
results.append({
'item': item,
'timestamp': timestamp,
'value': 100 - value,
})
else:
results.append({
'item': item,
'timestamp': timestamp,
'value': value,
})
# XXX: temporary hack: show zero as value if instance was created less then 30 minutes ago and actual value
# is not available
items_with_values = {r['item'] for r in results}
items_without_values = set(items) - items_with_values
timestamp = datetime_to_timestamp(timezone.now())
if items_without_values and instance.created > timezone.now() - timedelta(minutes=30):
for item in items_without_values:
results.append({'item': item, 'timestamp': timestamp, 'value': 0})
return results
def delete_host_and_service(instance):
if not ZABBIX_ENABLED:
return
try:
zabbix_client = ZabbixApiClient()
zabbix_client.delete_host(instance)
zabbix_client.delete_service(instance)
except ZabbixError as e:
# task does not have to fail if something is wrong with zabbix
logger.error('Zabbix host deletion flow has been broken %s' % e,
exc_info=1)
event_logger.zabbix.error(
'Unable to delete instance {instance_name} from Zabbix',
event_type='zabbix_host_deletion_failed',
event_context={'instance': instance})
else:
event_logger.zabbix.info(
'Deleted instance {instance_name} from Zabbix',
event_type='zabbix_host_deletion_succeeded',
event_context={'instance': instance})
def create_host_and_service(instance, warn_if_exists=True):
if not ZABBIX_ENABLED:
return
try:
zabbix_client = ZabbixApiClient()
zabbix_client.create_host(instance, warn_if_host_exists=warn_if_exists)
zabbix_client.create_service(instance,
warn_if_service_exists=warn_if_exists)
except ZabbixError as e:
# task does not have to fail if something is wrong with zabbix
logger.error('Zabbix host creation flow has been broken %s' % e,
exc_info=1)
event_logger.zabbix.error(
'Unable to add instance {instance_name} to Zabbix',
event_type='zabbix_host_creation_failed',
event_context={'instance': instance})
else:
event_logger.zabbix.info('Added instance {instance_name} to Zabbix',
event_type='zabbix_host_creation_succeeded',
event_context={'instance': instance})
class ZabbixPublicApiTest(unittest.TestCase):
def setUp(self):
self.zabbix_parameters = settings.NODECONDUCTOR['MONITORING']['ZABBIX']
self.api = get_mocked_zabbix_api()
self.zabbix_client = ZabbixApiClient()
self.zabbix_client.get_zabbix_api = Mock(return_value=self.api)
self.project = Mock()
self.project.name = 'test_project'
self.project.uuid = 'asdqwe1231232'
self.instance = Mock()
self.instance.uuid = 'qwedaqwedawqwqrt123sdasd123123'
self.instance.name = 'test_instance'
self.instance.cloud_project_membership.project = self.project
# Host creation
def test_create_host_creates_new_host_if_it_does_not_exist(self):
self.api.host.exists.return_value = False
self.zabbix_client.create_host(self.instance)
expected_host_name = self.zabbix_client.get_host_name(self.instance)
expected_visible_name = self.zabbix_client.get_host_visible_name(
self.instance)
self.api.host.exists.assert_called_once_with(host=expected_host_name)
self.api.host.create.assert_called_once_with({
"host":
expected_host_name,
"name":
expected_visible_name,
"interfaces": [self.zabbix_parameters['interface_parameters']],
"groups": [{
"groupid": '8'
}],
"templates": [{
"templateid": self.zabbix_parameters['templateid']
}],
})
def test_create_host_does_not_create_new_host_if_host_with_same_name_exists(
self):
self.zabbix_client.create_host(self.instance)
expected_host_name = self.zabbix_client.get_host_name(self.instance)
self.api.host.exists.assert_called_once_with(host=expected_host_name)
self.assertFalse(self.api.host.create.called,
'Host should not have been created')
def test_create_host_raises_zabbix_error_on_api_exception(self):
self.api.host.exists.side_effect = ZabbixAPIException
self.assertRaises(
ZabbixError, lambda: self.zabbix_client.create_host(self.instance))
# Host visible name update
def test_host_visible_name_is_not_updated_if_host_does_not_exist(self):
self.api.host.exists = Mock(return_value=False)
self.zabbix_client.update_host_visible_name(self.instance)
expected_host_name = self.zabbix_client.get_host_name(self.instance)
self.api.host.exists.assert_called_once_with(host=expected_host_name)
self.assertFalse(self.api.host.update.called,
'Host visible name should not have been updated')
def test_visible_name_is_updated_if_host_exists(self):
self.zabbix_client.update_host_visible_name(self.instance)
expected_host_name = self.zabbix_client.get_host_name(self.instance)
expected_visible_name = self.zabbix_client.get_host_visible_name(
self.instance)
self.api.host.exists.assert_called_once_with(host=expected_host_name)
self.api.host.update.assert_called_once_with({
"host":
expected_host_name,
"name":
expected_visible_name,
})
def test_update_host_visible_name_raises_zabbix_error_on_api_exception(
self):
self.api.host.exists.side_effect = ZabbixAPIException
self.assertRaises(
ZabbixError,
lambda: self.zabbix_client.update_host_visible_name(self.instance))
# Host deletion
def test_delete_host_deletes_host_if_it_exists(self):
self.zabbix_client.delete_host(self.instance)
expected_host_name = self.zabbix_client.get_host_name(self.instance)
self.api.host.get.assert_called_once_with(
filter={'host': expected_host_name})
self.api.host.delete.assert_called_once_with(1)
def test_delete_host_does_not_delete_host_if_it_does_not_exist(self):
self.api.host.get.return_value = []
self.zabbix_client.delete_host(self.instance)
expected_host_name = self.zabbix_client.get_host_name(self.instance)
self.api.host.get.assert_called_once_with(
filter={'host': expected_host_name})
self.assertFalse(self.api.host.delete.called,
'Host should not have been deleted')
def test_delete_host_raises_zabbix_error_on_api_exception(self):
self.api.host.get.side_effect = ZabbixAPIException
self.assertRaises(
ZabbixError, lambda: self.zabbix_client.delete_host(self.instance))
# Hostgroup creation
def test_create_hostgroup_creates_new_hostgroup_if_it_does_not_exist(self):
self.api.hostgroup.exists.return_value = False
self.zabbix_client.create_hostgroup(self.project)
expected_hostgroup_name = self.zabbix_client.get_hostgroup_name(
self.project)
self.api.hostgroup.exists.assert_called_once_with(
name=expected_hostgroup_name)
self.api.hostgroup.create.assert_called_once_with(
{"name": expected_hostgroup_name})
def test_create_hostgroup_does_not_create_new_hostgroup_if_hostgroup_with_same_name_exists(
self):
self.zabbix_client.create_hostgroup(self.project)
expected_hostgroup_name = self.zabbix_client.get_hostgroup_name(
self.project)
self.api.hostgroup.exists.assert_called_once_with(
name=expected_hostgroup_name)
self.assertFalse(self.api.hostgroup.create.called,
'Hostgroup should not have been created')
def test_create_hostgroup_raises_zabbix_error_on_api_exception(self):
self.api.hostgroup.exists.side_effect = ZabbixAPIException
self.assertRaises(
ZabbixError,
lambda: self.zabbix_client.create_hostgroup(self.project))
# Hostgroup deletion
def test_delete_hostgroup_deletes_host_if_it_exists(self):
self.zabbix_client.delete_hostgroup(self.project)
expected_hostgroup_name = self.zabbix_client.get_hostgroup_name(
self.project)
self.api.hostgroup.get.assert_called_once_with(
filter={'name': expected_hostgroup_name})
self.api.hostgroup.delete.assert_called_once_with(1)
def test_delete_hostgroup_does_not_delete_host_if_it_does_not_exist(self):
self.api.hostgroup.get.return_value = []
self.zabbix_client.delete_hostgroup(self.project)
expected_hostgroup_name = self.zabbix_client.get_hostgroup_name(
self.project)
self.api.hostgroup.get.assert_called_once_with(
filter={'name': expected_hostgroup_name})
self.assertFalse(self.api.hostgroup.delete.called,
'Hostgroup should not have been deleted')
def test_delete_hostgroup_raises_zabbix_error_on_api_exception(self):
self.api.hostgroup.get.side_effect = ZabbixAPIException
self.assertRaises(
ZabbixError,
lambda: self.zabbix_client.delete_hostgroup(self.project))
# Service creation
def test_create_service_uses_given_template_trigger(self):
self.zabbix_client.create_service(self.instance)
self.api.trigger.get.assert_called_once_with(
hostids=self.zabbix_client.get_host(self.instance)['hostid'])
def test_create_service_creates_new_service_if_it_does_not_exist(self):
self.api.service.get.return_value = []
self.zabbix_client.create_service(self.instance)
expected_service_name = self.zabbix_client.get_service_name(
self.instance)
call_args = self.zabbix_parameters['default_service_parameters'].copy()
call_args['name'] = expected_service_name
call_args['triggerid'] = 1
self.api.service.create.assert_called_once_with(call_args)
def test_create_service_does_not_create_new_service_if_service_with_same_name_exists(
self):
self.zabbix_client.create_service(self.instance)
self.assertFalse(self.api.service.create.called,
'Service should not have been created')
def test_create_service_raises_zabbix_error_on_api_exception(self):
self.api.service.get.side_effect = ZabbixAPIException
self.assertRaises(
ZabbixError,
lambda: self.zabbix_client.create_service(self.instance))
# Service deletion
def test_delete_service_deletes_host_if_it_exists(self):
self.zabbix_client.delete_service(self.instance)
expected_service_name = self.zabbix_client.get_service_name(
self.instance)
self.api.service.get.assert_called_once_with(
filter={'name': expected_service_name})
self.api.service.delete.assert_called_once_with(1)
def test_delete_service_does_not_delete_host_if_it_does_not_exist(self):
self.api.service.get.return_value = []
self.zabbix_client.delete_service(self.instance)
expected_service_name = self.zabbix_client.get_service_name(
self.instance)
self.api.service.get.assert_called_once_with(
filter={'name': expected_service_name})
self.assertFalse(self.api.service.delete.called,
'Hostgroup should not have been deleted')
def test_delete_service_raises_zabbix_error_on_api_exception(self):
self.api.service.get.side_effect = ZabbixAPIException
self.assertRaises(
ZabbixError,
lambda: self.zabbix_client.delete_service(self.instance))
def test_get_host_returns_hosts_if_it_exists(self):
host = self.zabbix_client.get_host(self.instance)
expected_host_name = self.zabbix_client.get_host_name(self.instance)
self.assertEquals(host, {'hostid': 1})
self.api.host.get.assert_called_once_with(
filter={'host': expected_host_name})
def test_get_host_raises_error_if_host_does_not_exist(self):
self.api.host.get.return_value = []
self.assertRaises(ZabbixError,
lambda: self.zabbix_client.get_host(self.instance))
def delete_zabbix_hostgroup(project_uuid):
project = models.Project.objects.get(uuid=project_uuid)
zabbix_client = ZabbixApiClient()
zabbix_client.delete_hostgroup(project)