def patch_data(self): # pragma: no cover
"""
Display QDialog for patch
"""
notes_dialog = EditQDialog()
notes_dialog.initialize(
_('Edit Host Notes'),
self.host_item.data['notes']
)
if notes_dialog.exec_() == EditQDialog.Accepted:
data = {'notes': str(notes_dialog.text_edit.toPlainText())}
headers = {'If-Match': self.host_item.data['_etag']}
endpoint = '/'.join(['host', self.host_item.item_id])
patched = app_backend.patch(endpoint, data, headers)
if patched:
data_manager.update_item_data(
self.host_item.item_type,
self.host_item.item_id,
{'notes': notes_dialog.text_edit.toPlainText()}
)
self.labels['notes'].setText(notes_dialog.text_edit.toPlainText())
message = _(
_("Host notes have been edited.")
)
send_event('INFO', message)
else:
send_event(
'ERROR',
_("Backend PATCH failed, please check your logs !")
)
def patch_data(self): # pragma: no cover
"""
Display QDialog for patch
"""
notes_dialog = EditQDialog()
notes_dialog.initialize(_('Edit Host Notes'),
self.host_item.data['notes'])
if notes_dialog.exec_() == EditQDialog.Accepted:
data = {'notes': str(notes_dialog.text_edit.toPlainText())}
headers = {'If-Match': self.host_item.data['_etag']}
endpoint = '/'.join(['host', self.host_item.item_id])
patched = app_backend.patch(endpoint, data, headers)
if patched:
data_manager.update_item_data(
self.host_item.item_type, self.host_item.item_id,
{'notes': notes_dialog.text_edit.toPlainText()})
self.labels['notes'].setText(
notes_dialog.text_edit.toPlainText())
message = _(_("Host notes have been edited."))
send_event('INFO', message)
else:
send_event('ERROR',
_("Backend PATCH failed, please check your logs !"))
def patch_host_checks(self, check_type, state): # pragma: no cover
"""
Patch the host check: 'active_checks_enabled' | 'passive_checks_enabled'
:param check_type: type of check: 'active_checks_enabled' | 'passive_checks_enabled'
:type check_type: str
:param state: state of Toggle button
:type state: bool
"""
data = {check_type: state}
headers = {'If-Match': self.host_item.data['_etag']}
endpoint = '/'.join([self.host_item.item_type, self.host_item.item_id])
patched = app_backend.patch(endpoint, data, headers)
if patched:
self.host_item.data[check_type] = state
data_manager.update_item_data(
self.host_item.item_type, self.host_item.item_id, self.host_item.data
)
enabled = _('enabled') if state else _('disabled')
event_type = 'OK' if state else 'WARN'
message = _(
_('%s %s for %s' %
(Item.get_check_text(check_type), enabled, self.host_item.get_display_name()))
)
send_event(event_type, message, timer=True)
else:
send_event(
'ERROR',
_("Backend PATCH failed, please check your logs !")
)
def query_history(self, hostname=None, host_id=None):
"""
Launch request on "history" endpoint but only for hosts in "data_manager"
:param hostname: name of host we want history
:type hostname: str
:param host_id: id of host for history
:type host_id: str
"""
request_model = History.get_request_model()
if hostname and host_id:
request_model['params']['where'] = json.dumps({'host': host_id})
request_model['params']['max_results'] = 25
request = self.get(request_model['endpoint'],
request_model['params'],
request_model['projection'],
all_items=False)
if request:
logger.debug('Add / Update history for %s (%s)', hostname,
host_id)
if data_manager.get_item('history', host_id):
data_manager.update_item_data('history', host_id,
request['_items'])
else:
host_history = History()
host_history.create(
host_id,
request['_items'],
hostname,
)
data_manager.database['history'].append(host_history)
else: # pragma: no cover, too long to test
history_list = []
for history in data_manager.database['history']:
request_model['params']['where'] = json.dumps(
{'host': history.item_id})
request_model['params']['max_results'] = 25
request = self.get(request_model['endpoint'],
request_model['params'],
request_model['projection'],
all_items=False)
if request:
host_history = History()
host_history.create(
history.item_id,
request['_items'],
history.name,
)
history_list.append(host_history)
if history_list:
data_manager.update_database('history', history_list)
def patch_host_checks(self, check_type, state): # pragma: no cover
"""
Patch the host check: 'active_checks_enabled' | 'passive_checks_enabled'
:param check_type: type of check: 'active_checks_enabled' | 'passive_checks_enabled'
:type check_type: str
:param state: state of Toggle button
:type state: bool
"""
data = {check_type: state}
headers = {'If-Match': self.host_item.data['_etag']}
endpoint = '/'.join([self.host_item.item_type, self.host_item.item_id])
patched = app_backend.patch(endpoint, data, headers)
if patched:
self.host_item.data[check_type] = state
data_manager.update_item_data(self.host_item.item_type,
self.host_item.item_id,
self.host_item.data)
enabled = _('enabled') if state else _('disabled')
event_type = 'OK' if state else 'WARN'
message = _(
_('%s %s for %s' % (Item.get_check_text(check_type), enabled,
self.host_item.get_display_name())))
send_event(event_type, message, timer=True)
else:
send_event('ERROR',
_("Backend PATCH failed, please check your logs !"))
def query_services(self, host_id=None):
"""
Launch request for "service" endpoint. If ``host_id`` is given, only services related to
host are added / updated
:param host_id: "_id" of host
:type host_id: str
"""
request_model = Service.get_request_model(host_id)
request = self.get(request_model['endpoint'],
request_model['params'],
request_model['projection'],
all_items=True)
if request:
services_list = []
for backend_item in request['_items']:
service = Service()
service.create(
backend_item['_id'],
backend_item,
backend_item['name'],
)
# Add / update only services of host "if host_id"
if host_id:
if not data_manager.get_item('service', service.item_id):
logger.debug('Add item data in database[service]')
data_manager.database['service'].append(service)
else:
data_manager.update_item_data('service',
service.item_id,
service.data)
# If not item ID, update all database
if services_list and not host_id:
data_manager.update_database('service', services_list)
if host_id:
host = data_manager.get_item('host', '_id', host_id)
if host:
logger.info('Update database[service] for %s', host.name)
if 'OK' in request['_status']:
data_manager.db_is_ready[request_model['endpoint']] = True
def query_services(self, host_id=None):
"""
Launch request for "service" endpoint. If ``host_id`` is given, only services related to
host are added / updated
:param host_id: "_id" of host
:type host_id: str
"""
request_model = Service.get_request_model(host_id)
request = self.get(
request_model['endpoint'],
request_model['params'],
request_model['projection'],
all_items=True
)
if request:
services_list = []
for backend_item in request['_items']:
service = Service()
service.create(
backend_item['_id'],
backend_item,
backend_item['name'],
)
# Add / update only services of host "if host_id"
if host_id:
if not data_manager.get_item('service', service.item_id):
logger.debug('Add item data in database[service]')
data_manager.database['service'].append(service)
else:
data_manager.update_item_data('service', service.item_id, service.data)
# If not item ID, update all database
if services_list and not host_id:
data_manager.update_database('service', services_list)
if host_id:
host = data_manager.get_item('host', '_id', host_id)
if host:
logger.info('Update database[service] for %s', host.name)
if 'OK' in request['_status']:
data_manager.db_is_ready[request_model['endpoint']] = True
def add_acknowledge(self): # pragma: no cover
"""
Create AckQDialog and manage acknowledge
"""
# Initial comment
user = data_manager.database['user']
comment = _('%s %s acknowledged by %s, from Alignak-app') % (
self.item.item_type.capitalize(), self.item.get_display_name(), user.name
)
# Acknowledge dialog
ack_dialog = AckQDialog()
ack_dialog.initialize(self.item.item_type, self.item.get_display_name(), comment)
if ack_dialog.exec_() == AckQDialog.Accepted:
sticky = ack_dialog.sticky_toggle_btn.is_checked()
notify = ack_dialog.notify_toggle_btn.is_checked()
comment = str(ack_dialog.ack_comment_edit.toPlainText())
post = app_backend.acknowledge(self.item, sticky, notify, comment)
send_event(
'ACK',
_('Acknowledge for %s is %s') % (self.item.get_display_name(), post['_status'])
)
# Update Item
data_manager.update_item_data(
self.item.item_type,
self.item.item_id,
{'ls_acknowledged': True}
)
data_manager.remove_item(
'problems',
self.item.item_id
)
logger.debug('ACK answer for %s: %s', self.item.name, post)
try:
self.acknowledge_btn.setEnabled(False)
except RuntimeError as e:
logger.warning('Can\'t disable Acknowledge btn: %s', e)
else:
logger.info('Acknowledge for %s cancelled...', self.item.name)
def add_downtime(self): # pragma: no cover
"""
Create DownQDialog and manage downtime
"""
user = data_manager.database['user']
comment = _('Schedule downtime on %s %s by %s, from Alignak-app') % (
self.item.item_type.capitalize(), self.item.get_display_name(), user.name
)
downtime_dialog = DownQDialog()
downtime_dialog.initialize(self.item.item_type, self.item.get_display_name(), comment)
if downtime_dialog.exec_() == DownQDialog.Accepted:
fixed = downtime_dialog.fixed_toggle_btn.is_checked()
duration = downtime_dialog.duration_to_seconds()
start_stamp = downtime_dialog.start_time.dateTime().toTime_t()
end_stamp = downtime_dialog.end_time.dateTime().toTime_t()
comment = downtime_dialog.comment_edit.toPlainText()
post = app_backend.downtime(self.item, fixed, duration, start_stamp, end_stamp, comment)
send_event(
'DOWNTIME',
_('Downtime for %s is %s') % (self.item.get_display_name(), post['_status'])
)
data_manager.update_item_data(
self.item.item_type,
self.item.item_id,
{'ls_downtimed': True}
)
data_manager.remove_item(
'problems',
self.item.item_id
)
logger.debug('DOWNTIME answer for %s: %s', self.item.name, post)
try:
self.downtime_btn.setEnabled(False)
except RuntimeError as e:
logger.warning('Can\'t disable Downtime btn: %s', e)
else:
logger.info('Downtime for %s cancelled...', self.item.name)
def query_services_problems(self, state):
"""
Launch requests on "service" endpoint to get items with "ls_state = state"
Wanted states are: ``WARNING``, ``CRITICAL`` and ``UNKNOWN``
:param state: state of service
:type state: str
"""
# Services
services_projection = [
'name', 'host', 'alias', 'ls_state', 'ls_output',
'ls_acknowledged', 'ls_downtimed', 'passive_checks_enabled',
'active_checks_enabled'
]
params = {
'where': json.dumps({
'_is_template': False,
'ls_state': state
})
}
request = self.get('service',
params,
services_projection,
all_items=True)
if request:
for backend_item in request['_items']:
if data_manager.is_problem('service', backend_item):
service = Service()
service.create(backend_item['_id'], backend_item,
backend_item['name'])
if data_manager.get_item('problems', service.item_id):
data_manager.update_item_data('problems',
service.item_id,
service.data)
else:
data_manager.database['problems'].append(service)
# Problems state is ready
data_manager.db_is_ready['problems'][state] = True
logger.info("Update database[problems] for %s services...", state)
def add_downtime(self): # pragma: no cover
"""
Create DownQDialog and manage downtime
"""
user = data_manager.database['user']
comment = _('Schedule downtime on %s %s by %s, from Alignak-app') % (
self.item.item_type.capitalize(), self.item.get_display_name(),
user.name)
downtime_dialog = DownQDialog()
downtime_dialog.initialize(self.item.item_type,
self.item.get_display_name(), comment)
if downtime_dialog.exec_() == DownQDialog.Accepted:
fixed = downtime_dialog.fixed_toggle_btn.is_checked()
duration = downtime_dialog.duration_to_seconds()
start_stamp = downtime_dialog.start_time.dateTime().toTime_t()
end_stamp = downtime_dialog.end_time.dateTime().toTime_t()
comment = downtime_dialog.comment_edit.toPlainText()
post = app_backend.downtime(self.item, fixed, duration,
start_stamp, end_stamp, comment)
send_event(
'DOWNTIME',
_('Downtime for %s is %s') %
(self.item.get_display_name(), post['_status']))
data_manager.update_item_data(self.item.item_type,
self.item.item_id,
{'ls_downtimed': True})
data_manager.remove_item('problems', self.item.item_id)
logger.debug('DOWNTIME answer for %s: %s', self.item.name, post)
try:
self.downtime_btn.setEnabled(False)
except RuntimeError as e:
logger.warning('Can\'t disable Downtime btn: %s', e)
else:
logger.info('Downtime for %s cancelled...', self.item.name)
def add_acknowledge(self): # pragma: no cover
"""
Create AckQDialog and manage acknowledge
"""
# Initial comment
user = data_manager.database['user']
comment = _('%s %s acknowledged by %s, from Alignak-app') % (
self.item.item_type.capitalize(), self.item.get_display_name(),
user.name)
# Acknowledge dialog
ack_dialog = AckQDialog()
ack_dialog.initialize(self.item.item_type,
self.item.get_display_name(), comment)
if ack_dialog.exec_() == AckQDialog.Accepted:
sticky = ack_dialog.sticky_toggle_btn.is_checked()
notify = ack_dialog.notify_toggle_btn.is_checked()
comment = str(ack_dialog.ack_comment_edit.toPlainText())
post = app_backend.acknowledge(self.item, sticky, notify, comment)
send_event(
'ACK',
_('Acknowledge for %s is %s') %
(self.item.get_display_name(), post['_status']))
# Update Item
data_manager.update_item_data(self.item.item_type,
self.item.item_id,
{'ls_acknowledged': True})
data_manager.remove_item('problems', self.item.item_id)
logger.debug('ACK answer for %s: %s', self.item.name, post)
try:
self.acknowledge_btn.setEnabled(False)
except RuntimeError as e:
logger.warning('Can\'t disable Acknowledge btn: %s', e)
else:
logger.info('Acknowledge for %s cancelled...', self.item.name)
def query_services_problems(self, state):
"""
Launch requests on "service" endpoint to get items with "ls_state = state"
Wanted states are: ``WARNING``, ``CRITICAL`` and ``UNKNOWN``
:param state: state of service
:type state: str
"""
# Services
services_projection = [
'name', 'host', 'alias', 'ls_state', 'ls_output', 'ls_acknowledged', 'ls_downtimed',
'passive_checks_enabled', 'active_checks_enabled'
]
params = {'where': json.dumps({'_is_template': False, 'ls_state': state})}
request = self.get(
'service',
params,
services_projection,
all_items=True
)
if request:
for backend_item in request['_items']:
if data_manager.is_problem('service', backend_item):
service = Service()
service.create(
backend_item['_id'],
backend_item,
backend_item['name']
)
if data_manager.get_item('problems', service.item_id):
data_manager.update_item_data('problems', service.item_id, service.data)
else:
data_manager.database['problems'].append(service)
# Problems state is ready
data_manager.db_is_ready['problems'][state] = True
logger.info("Update database[problems] for %s services...", state)
def query_hosts(self):
"""
Launch request on "host" endpoint, add hosts in problems if needed
"""
request_model = Host.get_request_model()
request = self.get(
request_model['endpoint'],
request_model['params'],
request_model['projection'],
all_items=True
)
if request:
hosts_list = []
for backend_item in request['_items']:
host = Host()
host.create(
backend_item['_id'],
backend_item,
backend_item['name'],
)
hosts_list.append(host)
# If host is a problem, add / update it
if data_manager.is_problem('host', backend_item):
if data_manager.get_item('problems', host.item_id):
data_manager.update_item_data('problems', host.item_id, host.data)
else:
data_manager.database['problems'].append(host)
data_manager.db_is_ready['problems']['host'] = True
if hosts_list:
data_manager.update_database('host', hosts_list)
if 'OK' in request['_status']:
data_manager.db_is_ready[request_model['endpoint']] = True
def query_hosts(self):
"""
Launch request on "host" endpoint, add hosts in problems if needed
"""
request_model = Host.get_request_model()
request = self.get(request_model['endpoint'],
request_model['params'],
request_model['projection'],
all_items=True)
if request:
hosts_list = []
for backend_item in request['_items']:
host = Host()
host.create(
backend_item['_id'],
backend_item,
backend_item['name'],
)
hosts_list.append(host)
# If host is a problem, add / update it
if data_manager.is_problem('host', backend_item):
if data_manager.get_item('problems', host.item_id):
data_manager.update_item_data('problems', host.item_id,
host.data)
else:
data_manager.database['problems'].append(host)
data_manager.db_is_ready['problems']['host'] = True
if hosts_list:
data_manager.update_database('host', hosts_list)
if 'OK' in request['_status']:
data_manager.db_is_ready[request_model['endpoint']] = True
def query_history(self, hostname=None, host_id=None):
"""
Launch request on "history" endpoint but only for hosts in "data_manager"
:param hostname: name of host we want history
:type hostname: str
:param host_id: id of host for history
:type host_id: str
"""
request_model = History.get_request_model()
if hostname and host_id:
request_model['params']['where'] = json.dumps({
'host': host_id})
request_model['params']['max_results'] = 25
request = self.get(
request_model['endpoint'],
request_model['params'],
request_model['projection'],
all_items=False
)
if request:
logger.debug('Add / Update history for %s (%s)', hostname, host_id)
if data_manager.get_item('history', host_id):
data_manager.update_item_data('history', host_id, request['_items'])
else:
host_history = History()
host_history.create(
host_id,
request['_items'],
hostname,
)
data_manager.database['history'].append(host_history)
else: # pragma: no cover, too long to test
history_list = []
for history in data_manager.database['history']:
request_model['params']['where'] = json.dumps({
'host': history.item_id})
request_model['params']['max_results'] = 25
request = self.get(
request_model['endpoint'],
request_model['params'],
request_model['projection'],
all_items=False
)
if request:
host_history = History()
host_history.create(
history.item_id,
request['_items'],
history.name,
)
history_list.append(host_history)
if history_list:
data_manager.update_database('history', history_list)
