def test_patch(self):
"""PATCH User Notes"""
under_test = BackendClient()
under_test.login(
settings.get_config('Alignak', 'username'),
settings.get_config('Alignak', 'password')
)
users = under_test.get('user')
user = users['_items'][0]
notes = 'Unit Test from Alignak-app'
data = {'notes': notes}
headers = {'If-Match': user['_etag']}
endpoint = '/'.join(['user', user['_id']])
patched = under_test.patch(endpoint, data, headers)
self.assertTrue(patched)
user_modified = under_test.get('/'.join(['user', user['_id']]))
self.assertEqual(user_modified['notes'], notes)
back_patched = under_test.patch(endpoint, data={'notes': ''}, headers=headers)
self.assertTrue(back_patched)
user_modified = under_test.get('/'.join(['user', user['_id']]))
self.assertNotEqual(user_modified['notes'], notes)
self.assertEqual(user_modified['notes'], '')
def test_patch(self):
"""PATCH User Notes"""
under_test = BackendClient()
under_test.login(settings.get_config('Alignak', 'username'),
settings.get_config('Alignak', 'password'))
users = under_test.get('user')
user = users['_items'][0]
notes = 'Unit Test from Alignak-app'
data = {'notes': notes}
headers = {'If-Match': user['_etag']}
endpoint = '/'.join(['user', user['_id']])
patched = under_test.patch(endpoint, data, headers)
self.assertTrue(patched)
user_modified = under_test.get('/'.join(['user', user['_id']]))
self.assertEqual(user_modified['notes'], notes)
back_patched = under_test.patch(endpoint,
data={'notes': ''},
headers=headers)
self.assertTrue(back_patched)
user_modified = under_test.get('/'.join(['user', user['_id']]))
self.assertNotEqual(user_modified['notes'], notes)
self.assertEqual(user_modified['notes'], '')
def init_localization(): # pragma: no cover
"""
Application localization
:return: gettext translator method
:rtype: method
"""
try:
# Language message file
lang_filename = os.path.join(
os.path.abspath(os.path.dirname(__file__)),
"LC_MESSAGES/%s.mo" % settings.get_config('Alignak-app', 'locale'))
logger.info("Opening message file %s for locale %s", lang_filename,
settings.get_config('Alignak-app', 'locale'))
translation = GNUTranslations(open(lang_filename, "rb"))
translation.install()
_ = translation.gettext
except IOError:
logger.warning(
"Locale not found. Using default language messages (English)")
null_translation = NullTranslations()
null_translation.install()
_ = null_translation.gettext
except Exception as e: # pragma: no cover - should not happen
logger.error("Locale not found. Exception: %s", str(e))
null_translation = NullTranslations()
null_translation.install()
_ = null_translation.gettext
return _
def test_actions_buttons_are_updated(self):
"""Actions Buttons are Updated"""
under_test = ActionsQWidget()
self.assertIsNone(under_test.item)
host_test = Host()
host_test.create(
'id_1',
{
'ls_acknowledged': False,
'ls_downtimed': False,
'_id': 'id_1',
'ls_state': 'DOWN'
},
'name'
)
under_test.initialize(host_test)
# Actions buttons are True by default
self.assertTrue(under_test.acknowledge_btn.isEnabled())
self.assertTrue(under_test.downtime_btn.isEnabled())
self.assertIsNotNone(under_test.item)
# Log to backend and fill datamanager
app_backend.login(
settings.get_config('Alignak', 'username'),
settings.get_config('Alignak', 'password')
)
data_manager.update_database('host', [host_test])
# Update widget
under_test.update_widget()
webservice_test = settings.get_config('Alignak', 'webservice')
self.assertTrue(webservice_test)
if app_backend.ws_client.auth:
# WS is set but not available, so buttons are disabled
self.assertTrue(under_test.acknowledge_btn.isEnabled())
self.assertTrue(under_test.downtime_btn.isEnabled())
else:
# WS is set but not available, so buttons are disabled
self.assertFalse(under_test.acknowledge_btn.isEnabled())
self.assertFalse(under_test.downtime_btn.isEnabled())
# remove WS
settings.set_config('Alignak', 'webservice', '')
under_test.update_widget()
# Only downtime button is Enabled, because host is UP
self.assertTrue(under_test.acknowledge_btn.isEnabled())
self.assertTrue(under_test.downtime_btn.isEnabled())
# Restore configurations
settings.set_config('Alignak', 'webservice', webservice_test)
app_backend.connected = False
app_backend.user = {}
def test_actions_buttons_are_updated(self):
"""Actions Buttons are Updated"""
under_test = ActionsQWidget()
self.assertIsNone(under_test.item)
host_test = Host()
host_test.create(
'id_1', {
'ls_acknowledged': False,
'ls_downtimed': False,
'_id': 'id_1',
'ls_state': 'DOWN'
}, 'name')
under_test.initialize(host_test)
# Actions buttons are True by default
self.assertTrue(under_test.acknowledge_btn.isEnabled())
self.assertTrue(under_test.downtime_btn.isEnabled())
self.assertIsNotNone(under_test.item)
# Log to backend and fill datamanager
app_backend.login(settings.get_config('Alignak', 'username'),
settings.get_config('Alignak', 'password'))
data_manager.update_database('host', [host_test])
# Update widget
under_test.update_widget()
webservice_test = settings.get_config('Alignak', 'webservice')
self.assertTrue(webservice_test)
if app_backend.ws_client.auth:
# WS is set but not available, so buttons are disabled
self.assertTrue(under_test.acknowledge_btn.isEnabled())
self.assertTrue(under_test.downtime_btn.isEnabled())
else:
# WS is set but not available, so buttons are disabled
self.assertFalse(under_test.acknowledge_btn.isEnabled())
self.assertFalse(under_test.downtime_btn.isEnabled())
# remove WS
settings.set_config('Alignak', 'webservice', '')
under_test.update_widget()
# Only downtime button is Enabled, because host is UP
self.assertTrue(under_test.acknowledge_btn.isEnabled())
self.assertTrue(under_test.downtime_btn.isEnabled())
# Restore configurations
settings.set_config('Alignak', 'webservice', webservice_test)
app_backend.connected = False
app_backend.user = {}
def test_query_period_data(self):
"""Query TimePeriod Data"""
under_test = BackendClient()
under_test.login(settings.get_config('Alignak', 'username'),
settings.get_config('Alignak', 'password'))
from alignak_app.backend.datamanager import data_manager
under_test.query_timeperiods()
self.assertIsNotNone(data_manager.database['timeperiod'])
self.assertTrue(data_manager.db_is_ready['timeperiod'])
def test_get_backend_status_icon(self):
"""Get Backend Status Icon Name"""
backend_test = BackendClient()
under_test = backend_test.get_backend_status_icon()
self.assertEqual('disconnected', under_test)
backend_test.login(settings.get_config('Alignak', 'username'),
settings.get_config('Alignak', 'password'))
under_test = backend_test.get_backend_status_icon()
self.assertEqual('connected', under_test)
def test_query_livesynthesis_data(self):
"""Query Live Synthesis Data"""
under_test = BackendClient()
under_test.login(settings.get_config('Alignak', 'username'),
settings.get_config('Alignak', 'password'))
from alignak_app.backend.datamanager import data_manager
under_test.query_livesynthesis()
self.assertIsNotNone(data_manager.database['livesynthesis'])
self.assertTrue(data_manager.db_is_ready['livesynthesis'])
def test_query_hosts_data(self):
"""Query Host Data"""
under_test = BackendClient()
under_test.login(settings.get_config('Alignak', 'username'),
settings.get_config('Alignak', 'password'))
from alignak_app.backend.datamanager import data_manager
under_test.query_hosts()
self.assertIsNotNone(data_manager.database['host'])
self.assertTrue(data_manager.db_is_ready['host'])
self.assertTrue(data_manager.db_is_ready['problems']['host'])
def test_query_problems(self):
"""Query Problems Data"""
under_test = BackendClient()
under_test.login(settings.get_config('Alignak', 'username'),
settings.get_config('Alignak', 'password'))
from alignak_app.backend.datamanager import data_manager
under_test.query_services_problems('WARNING')
self.assertIsNotNone(data_manager.database['problems'])
self.assertTrue(data_manager.db_is_ready['problems']['WARNING'])
under_test.query_services_problems('UNKNOWN')
self.assertTrue(data_manager.db_is_ready['problems']['UNKNOWN'])
def test_get_backend_status_icon(self):
"""Get Backend Status Icon Name"""
backend_test = BackendClient()
under_test = backend_test.get_backend_status_icon()
self.assertEqual('disconnected', under_test)
backend_test.login(
settings.get_config('Alignak', 'username'),
settings.get_config('Alignak', 'password')
)
under_test = backend_test.get_backend_status_icon()
self.assertEqual('connected', under_test)
def test_query_livesynthesis_data(self):
"""Query Live Synthesis Data"""
under_test = BackendClient()
under_test.login(
settings.get_config('Alignak', 'username'),
settings.get_config('Alignak', 'password')
)
from alignak_app.backend.datamanager import data_manager
under_test.query_livesynthesis()
self.assertIsNotNone(data_manager.database['livesynthesis'])
self.assertTrue(data_manager.db_is_ready['livesynthesis'])
def test_query_period_data(self):
"""Query TimePeriod Data"""
under_test = BackendClient()
under_test.login(
settings.get_config('Alignak', 'username'),
settings.get_config('Alignak', 'password')
)
from alignak_app.backend.datamanager import data_manager
under_test.query_timeperiods()
self.assertIsNotNone(data_manager.database['timeperiod'])
self.assertTrue(data_manager.db_is_ready['timeperiod'])
def daemon_is_problem(daemon_item):
"""
Check Daemon Refresh and if daemon is alive. Send a message if needed
:param daemon_item: Daemon item
:type daemon_item: alignak_app.items.daemon.Daemon
:return: if daemon is a problem True, else False
:rtype: bool
"""
is_problem = False
actual_freshness = get_diff_since_last_timestamp(
daemon_item.data['last_check'], 'minutes')
freshness = settings.get_config('Alignak-app', 'daemons_freshness')
if int(actual_freshness) > int(freshness):
send_event(
'CRITICAL' if 'arbiter' in daemon_item.name else 'WARNING',
_('Freshness expired for %s') % daemon_item.name,
timer=True)
is_problem = True
logger.warning('Daemon freshness expired: %s(%dmn)',
daemon_item.name, actual_freshness)
if not daemon_item.data['alive']:
send_event(
'CRITICAL' if 'arbiter' in daemon_item.name else 'WARNING',
_('Daemon %s is dead !') % daemon_item.name,
timer=True)
logger.warning('Daemon %s is dead...', daemon_item.name)
is_problem = True
return is_problem
def test_query_hosts_data(self):
"""Query Host Data"""
under_test = BackendClient()
under_test.login(
settings.get_config('Alignak', 'username'),
settings.get_config('Alignak', 'password')
)
from alignak_app.backend.datamanager import data_manager
under_test.query_hosts()
self.assertIsNotNone(data_manager.database['host'])
self.assertTrue(data_manager.db_is_ready['host'])
self.assertTrue(data_manager.db_is_ready['problems']['host'])
def initialize(self, spy_widget):
"""
Initialize QWidget and set SpyQWidget
:param spy_widget: instance of SpyQWidget to manage spy events
:type spy_widget: alignak_app.qobjects.events.spy.SpyQWidget
"""
problem_layout = QVBoxLayout()
problem_layout.setContentsMargins(5, 20, 5, 5)
self.setLayout(problem_layout)
self.spy_widget = spy_widget
self.problems_title.setObjectName('title')
problem_layout.addWidget(self.problems_title)
problem_layout.addWidget(self.get_search_widget())
problem_layout.addWidget(self.get_btn_widget())
problem_layout.addWidget(self.problems_table)
self.update_problems_data()
update_problems = int(settings.get_config('Alignak-app', 'update_problems')) * 1000
self.refresh_timer.setInterval(update_problems)
self.refresh_timer.start()
self.refresh_timer.timeout.connect(self.update_problems_data)
def login(self, token):
"""
Login to Web Service. Used only to ensure that the user token is identical
:param token: user's token of App
:type token: str
"""
self.ws_backend = settings.get_config('Alignak', 'webservice')
try:
# WS login
logger.info("Requesting Web Service authentication with token: %s", token)
headers = {'Content-Type': 'application/json'}
params = {'username': token, 'password': ''}
response = requests.post(
'/'.join([self.ws_backend, 'login']), json=params, headers=headers
)
resp = response.json()
if '_result' in resp:
assert token == resp['_result'][0]
self.token = token
self.auth = requests.auth.HTTPBasicAuth(self.token, '')
except (RequestsConnectionError, AssertionError) as exp:
msg = 'Connection to Web Service on [%s] has failed' % \
'/'.join([self.ws_backend, 'login'])
logger.warning(msg)
logger.debug(exp)
def initialize(self, spy_widget):
"""
Initialize QWidget and set SpyQWidget
:param spy_widget: instance of SpyQWidget to manage spy events
:type spy_widget: alignak_app.qobjects.events.spy.SpyQWidget
"""
problem_layout = QVBoxLayout()
problem_layout.setContentsMargins(5, 20, 5, 5)
self.setLayout(problem_layout)
self.spy_widget = spy_widget
self.problems_title.setObjectName('title')
problem_layout.addWidget(self.problems_title)
problem_layout.addWidget(self.get_search_widget())
problem_layout.addWidget(self.get_btn_widget())
problem_layout.addWidget(self.problems_table)
self.update_problems_data()
update_problems = int(
settings.get_config('Alignak-app', 'update_problems')) * 1000
self.refresh_timer.setInterval(update_problems)
self.refresh_timer.start()
self.refresh_timer.timeout.connect(self.update_problems_data)
def initialize(self):
"""
Initialize QWidget
"""
layout = QGridLayout()
self.setLayout(layout)
# Add Qwidgets
layout.addWidget(self.get_host_icon_widget(), 0, 0, 2, 1)
layout.addWidget(self.get_last_check_widget(), 0, 1, 1, 1)
layout.addWidget(self.get_variables_widget(), 0, 2, 1, 1)
layout.addWidget(self.get_notes_output_widget(), 1, 1, 1, 2)
layout.addWidget(self.get_actions_widget(), 0, 3, 2, 1)
update_host = int(settings.get_config('Alignak-app',
'update_host')) * 1000
self.refresh_timer.setInterval(update_host)
self.refresh_timer.start()
self.refresh_timer.timeout.connect(self.update_host)
def add_event(self, event_type, msg, timer=False, host=None):
"""
Add event to events list
:param event_type: the type of event: OK, DOWN, ACK, ...
:type event_type: str
:param msg: message of event
:type msg: str
:param timer: timer to hide event at end of time
:type timer: bool
:param host: data of a host to set ``Qt.UserRole``
:type host: None | str
"""
if not self.event_exist(msg):
logger.debug(
'Add Event: msg: %s, timer: %s, host: %s', msg, timer, host
)
event = EventItem()
event.initialize(event_type, msg, timer=timer, host=host)
self.events_list.insertItem(0, event)
if timer:
event_duration = int(
settings.get_config('Alignak-app', 'notification_duration')
) * 1000
QTimer.singleShot(
event_duration,
lambda: self.remove_timer_event(event)
)
else:
logger.debug(
'Event with msg: %s already exist.', msg
)
def daemon_is_problem(daemon_item):
"""
Check Daemon Refresh and if daemon is alive. Send a message if needed
:param daemon_item: Daemon item
:type daemon_item: alignak_app.items.daemon.Daemon
:return: if daemon is a problem True, else False
:rtype: bool
"""
is_problem = False
actual_freshness = get_diff_since_last_timestamp(
daemon_item.data['last_check'], 'minutes'
)
freshness = settings.get_config('Alignak-app', 'daemons_freshness')
if int(actual_freshness) > int(freshness):
send_event(
'CRITICAL' if 'arbiter' in daemon_item.name else 'WARNING',
_('Freshness expired for %s') % daemon_item.name,
timer=True
)
is_problem = True
logger.warning('Daemon freshness expired: %s(%dmn)', daemon_item.name, actual_freshness)
if not daemon_item.data['alive']:
send_event(
'CRITICAL' if 'arbiter' in daemon_item.name else 'WARNING',
_('Daemon %s is dead !') % daemon_item.name,
timer=True
)
logger.warning('Daemon %s is dead...', daemon_item.name)
is_problem = True
return is_problem
def add_event(self, event_type, msg, timer=False, host=None):
"""
Add event to events list
:param event_type: the type of event: OK, DOWN, ACK, ...
:type event_type: str
:param msg: message of event
:type msg: str
:param timer: timer to hide event at end of time
:type timer: bool
:param host: data of a host to set ``Qt.UserRole``
:type host: None | str
"""
if not self.event_exist(msg):
logger.debug('Add Event: msg: %s, timer: %s, host: %s', msg, timer,
host)
event = EventItem()
event.initialize(event_type, msg, timer=timer, host=host)
self.events_list.insertItem(0, event)
if timer:
event_duration = int(
settings.get_config('Alignak-app',
'notification_duration')) * 1000
QTimer.singleShot(event_duration,
lambda: self.remove_timer_event(event))
else:
logger.debug('Event with msg: %s already exist.', msg)
def test_initialize_server_dialog(self):
"""Initialize ServerQDialog"""
under_test = ServerQDialog()
self.assertIsInstance(under_test.server_proc, QLineEdit)
self.assertEqual('', under_test.server_proc.text())
self.assertIsInstance(under_test.server_port, QLineEdit)
self.assertEqual('', under_test.server_port.text())
self.assertIsInstance(under_test.server_url, QLineEdit)
self.assertEqual('', under_test.server_url.text())
self.assertIsInstance(under_test.webservice_url, QLineEdit)
self.assertEqual('', under_test.webservice_url.text())
self.assertIsNone(under_test.offset)
self.assertEqual('dialog', under_test.objectName())
under_test.initialize_dialog()
# After initialization,
# QLineEdit texts must be equal to what is defined in the configuration file
self.assertIsInstance(under_test.server_proc, QLineEdit)
self.assertEqual(
settings.get_config('Alignak', 'processes'),
under_test.server_proc.text()
)
self.assertIsInstance(under_test.server_port, QLineEdit)
self.assertEqual(
settings.get_config('Alignak', 'backend').split(':')[2],
under_test.server_port.text()
)
self.assertIsInstance(under_test.server_url, QLineEdit)
self.assertEqual(
settings.get_config('Alignak', 'url'),
under_test.server_url.text()
)
self.assertIsInstance(under_test.webservice_url, QLineEdit)
self.assertEqual(
settings.get_config('Alignak', 'webservice'),
under_test.webservice_url.text()
)
def test_query_problems(self):
"""Query Problems Data"""
under_test = BackendClient()
under_test.login(
settings.get_config('Alignak', 'username'),
settings.get_config('Alignak', 'password')
)
from alignak_app.backend.datamanager import data_manager
under_test.query_services_problems('WARNING')
self.assertIsNotNone(data_manager.database['problems'])
self.assertTrue(data_manager.db_is_ready['problems']['WARNING'])
under_test.query_services_problems('UNKNOWN')
self.assertTrue(data_manager.db_is_ready['problems']['UNKNOWN'])
def initialize(self):
"""
Initialize QMainWindow for App
"""
logger.info('Display Alignak-App...')
app_widget = QWidget()
app_widget.setObjectName('dialog')
app_layout = QGridLayout()
app_layout.setContentsMargins(0, 0, 0, 0)
app_widget.setLayout(app_layout)
# Logo widget
app_layout.addWidget(get_logo_widget(self, 'Alignak-App'), 0, 0, 1, 3)
# Panel
self.panel_widget.initialize()
app_layout.addWidget(self.panel_widget, 1, 0, 1, 1)
app_layout.addWidget(get_frame_separator(True), 1, 1, 1, 1)
# Dock
self.dock.initialize()
app_layout.addWidget(self.dock, 1, 2, 1, 1)
self.setCentralWidget(app_widget)
self.setMinimumSize(1440, 900)
center_widget(self)
display = settings.get_config('Alignak-app', 'display')
if "min" in display:
self.show()
elif "max" in display:
self.showMaximized()
else:
pass
if settings.get_config('Alignak-app', 'problems', boolean=True):
self.panel_widget.tab_widget.setCurrentIndex(
self.panel_widget.tab_widget.indexOf(self.panel_widget.problems_widget)
)
self.panel_widget.problems_widget.line_search.setFocus()
else:
self.panel_widget.synthesis_widget.line_search.setFocus()
def initialize(self):
"""
Initialize QMainWindow for App
"""
logger.info('Display Alignak-App...')
app_widget = QWidget()
app_widget.setObjectName('dialog')
app_layout = QGridLayout()
app_layout.setContentsMargins(0, 0, 0, 0)
app_widget.setLayout(app_layout)
# Logo widget
app_layout.addWidget(get_logo_widget(self, 'Alignak-App'), 0, 0, 1, 3)
# Panel
self.panel_widget.initialize()
app_layout.addWidget(self.panel_widget, 1, 0, 1, 1)
app_layout.addWidget(get_frame_separator(True), 1, 1, 1, 1)
# Dock
self.dock.initialize()
app_layout.addWidget(self.dock, 1, 2, 1, 1)
self.setCentralWidget(app_widget)
self.setMinimumSize(1440, 900)
center_widget(self)
display = settings.get_config('Alignak-app', 'display')
if "min" in display:
self.show()
elif "max" in display:
self.showMaximized()
else:
pass
if settings.get_config('Alignak-app', 'problems', boolean=True):
self.panel_widget.tab_widget.setCurrentIndex(
self.panel_widget.tab_widget.indexOf(
self.panel_widget.problems_widget))
self.panel_widget.problems_widget.line_search.setFocus()
else:
self.panel_widget.synthesis_widget.line_search.setFocus()
def test_log_to_backend(self):
"""Connection to Alignak-Backend"""
under_test = BackendClient()
connect = under_test.login(settings.get_config('Alignak', 'username'),
settings.get_config('Alignak', 'password'))
# Compare config url and app_backend
self.assertEquals(under_test.backend.url_endpoint_root,
settings.get_config('Alignak', 'backend'))
self.assertTrue(under_test.connected)
self.assertTrue(under_test.backend.authenticated)
self.assertTrue(connect)
# Assert on second connection, backend use token !
connect = under_test.login()
self.assertTrue(connect)
def test_app_main_window_display_settings(self):
"""Display AppQMainWindow at Start"""
under_test = AppQMainWindow()
data_manager.update_database('host', [])
data_manager.update_database('service', [])
self.assertFalse(under_test.isVisible())
settings.set_config('Alignak-app', 'display', 'min')
under_test.initialize()
# AppQMainWindow is visible but not maximized
self.assertEqual('min', settings.get_config('Alignak-app', 'display'))
self.assertTrue(under_test.isVisible())
self.assertFalse(under_test.isMaximized())
under_test.close()
settings.set_config('Alignak-app', 'display', 'max')
under_test = AppQMainWindow()
init_event_widget()
under_test.initialize()
# AppQMainWindow is visible and Maximized
self.assertEqual('max', settings.get_config('Alignak-app', 'display'))
self.assertTrue(under_test.isVisible())
self.assertTrue(under_test.isMaximized())
under_test.close()
settings.set_config('Alignak-app', 'display', 'no')
under_test = AppQMainWindow()
init_event_widget()
under_test.initialize()
# AppQMainWindow is not visible and not maximized
self.assertEqual('no', settings.get_config('Alignak-app', 'display'))
self.assertFalse(under_test.isVisible())
self.assertFalse(under_test.isMaximized())
under_test.close()
# Restore default setting
settings.set_config('Alignak-app', 'display', 'min')
def test_app_main_window_display_settings(self):
"""Display AppQMainWindow at Start"""
under_test = AppQMainWindow()
data_manager.update_database('host', [])
data_manager.update_database('service', [])
self.assertFalse(under_test.isVisible())
settings.set_config('Alignak-app', 'display', 'min')
under_test.initialize()
# AppQMainWindow is visible but not maximized
self.assertEqual('min', settings.get_config('Alignak-app', 'display'))
self.assertTrue(under_test.isVisible())
self.assertFalse(under_test.isMaximized())
under_test.close()
settings.set_config('Alignak-app', 'display', 'max')
under_test = AppQMainWindow()
init_event_widget()
under_test.initialize()
# AppQMainWindow is visible and Maximized
self.assertEqual('max', settings.get_config('Alignak-app', 'display'))
self.assertTrue(under_test.isVisible())
self.assertTrue(under_test.isMaximized())
under_test.close()
settings.set_config('Alignak-app', 'display', 'no')
under_test = AppQMainWindow()
init_event_widget()
under_test.initialize()
# AppQMainWindow is not visible and not maximized
self.assertEqual('no', settings.get_config('Alignak-app', 'display'))
self.assertFalse(under_test.isVisible())
self.assertFalse(under_test.isMaximized())
under_test.close()
# Restore default setting
settings.set_config('Alignak-app', 'display', 'min')
def refresh_menus(self):
"""
Refresh menu if needed
"""
if settings.get_config('Alignak', 'webui'):
self.tray_actions['webui'].setEnabled(True)
else:
self.tray_actions['webui'].setEnabled(False)
def can_submit_actions():
"""
Return if user can trigger actions from App or not, depending if Web Service is set and
reachable:
* If Web Service: if reachable, make actions are available else they are disabled
* If NOT Web Service: App will use backend API
:return: if user can trigger actions
:rtype: bool
"""
if not settings.get_config('Alignak', 'webservice') and app_backend.connected:
return True
if settings.get_config('Alignak', 'webservice') and app_backend.ws_client.auth:
return True
return False
def test_login_ws_with_wrong_token(self):
"""Login to WS with Wrong Token"""
under_test = WSClient()
under_test.login('')
self.assertFalse(under_test.token)
config_url = settings.get_config('Alignak', 'webservice')
self.assertEqual(config_url, under_test.ws_backend)
# WS is not auth
self.assertIsNone(under_test.auth)
def can_submit_actions():
"""
Return if user can trigger actions from App or not, depending if Web Service is set and
reachable:
* If Web Service: if reachable, make actions are available else they are disabled
* If NOT Web Service: App will use backend API
:return: if user can trigger actions
:rtype: bool
"""
if not settings.get_config('Alignak',
'webservice') and app_backend.connected:
return True
if settings.get_config('Alignak',
'webservice') and app_backend.ws_client.auth:
return True
return False
def initialize(self):
"""
Intialize Spy QWidget
"""
layout = QGridLayout()
self.setLayout(layout)
spy_icon = QLabel()
spy_pixmap = QPixmap(settings.get_image('spy'))
spy_icon.setPixmap(spy_pixmap)
spy_icon.setScaledContents(True)
spy_icon.setFixedSize(20, 20)
layout.addWidget(spy_icon, 0, 0, 1, 1)
layout.setAlignment(spy_icon, Qt.AlignRight)
spy_title = QLabel(_('Spy Hosts'))
spy_title.setObjectName('title')
spy_title.setMinimumHeight(40)
layout.addWidget(spy_title, 0, 1, 1, 1)
hint_lbl = QLabel('Click to refresh, double-click to stop spying')
hint_lbl.setObjectName('subtitle')
layout.addWidget(hint_lbl, 1, 0, 1, 1)
layout.setAlignment(hint_lbl, Qt.AlignCenter)
self.host_services_lbl.setObjectName('subtitle')
layout.addWidget(self.host_services_lbl, 1, 1, 1, 1)
layout.setAlignment(self.host_services_lbl, Qt.AlignCenter)
self.spy_list_widget.setDragDropMode(QAbstractItemView.DragDrop)
self.spy_list_widget.setSelectionMode(
QAbstractItemView.ExtendedSelection)
self.spy_list_widget.doubleClicked.connect(self.remove_event)
self.spy_list_widget.setAcceptDrops(True)
self.spy_list_widget.setWordWrap(True)
self.spy_list_widget.insertItem(0, self.get_hint_item())
self.spy_list_widget.item_dropped.connect(
get_events_widget().remove_event)
self.spy_list_widget.clicked.connect(
lambda: self.manage_host_events(self.spy_list_widget.currentRow()))
layout.addWidget(self.spy_list_widget, 2, 0, 1, 1)
self.host_list_widget.setObjectName('spy')
# self.host_list_widget.setMinimumWidth(500)
layout.addWidget(self.host_list_widget, 2, 1, 1, 1)
spy_interval = int(settings.get_config('Alignak-app',
'spy_interval')) * 1000
self.spy_timer.setInterval(spy_interval)
self.spy_timer.start()
self.spy_timer.timeout.connect(self.send_spy_events)
def test_get_endpoint_with_params_and_projection(self):
"""Backend GET"""
backend_test = BackendClient()
backend_test.login(settings.get_config('Alignak', 'username'),
settings.get_config('Alignak', 'password'))
# Get hosts states
test_projection = ['name', 'alias']
test_params = {'where': json.dumps({'_is_template': False})}
under_test = backend_test.get('host',
params=test_params,
projection=test_projection)
self.assertTrue(under_test)
self.assertTrue(under_test['_items'])
self.assertTrue('name' in under_test['_items'][0])
self.assertTrue('alias' in under_test['_items'][0])
def set_proxy_settings(self, proxy_password=None):
"""
Set the proxy settings, with password if given
:param proxy_password: the pasword of proxy
:type proxy_password: str
"""
if settings.get_config('Alignak', 'proxy_user'):
# Model is: {'http': 'http://*****:*****@proxy:port'}
protocol, address, port = settings.get_config('Alignak',
'proxy').split(':')
proxy_user = settings.get_config('Alignak', 'proxy_user')
address = address.replace('//', '')
proxy = {
protocol:
'%s://%s:%s@%s:%s' %
(protocol, proxy_user, proxy_password, address, port)
}
self.proxies = proxy
elif settings.get_config('Alignak', 'proxy'):
protocol = settings.get_config('Alignak', 'proxy').split(':')[0]
self.proxies = {protocol: settings.get_config('Alignak', 'proxy')}
else:
self.proxies = {}
def test_initialize_server_dialog(self):
"""Initialize ServerQDialog"""
under_test = ServerQDialog()
self.assertIsInstance(under_test.server_proc, QLineEdit)
self.assertEqual('', under_test.server_proc.text())
self.assertIsInstance(under_test.server_port, QLineEdit)
self.assertEqual('', under_test.server_port.text())
self.assertIsInstance(under_test.server_url, QLineEdit)
self.assertEqual('', under_test.server_url.text())
self.assertIsInstance(under_test.webservice_url, QLineEdit)
self.assertEqual('', under_test.webservice_url.text())
self.assertIsNone(under_test.offset)
self.assertEqual('dialog', under_test.objectName())
under_test.initialize_dialog()
# After initialization,
# QLineEdit texts must be equal to what is defined in the configuration file
self.assertIsInstance(under_test.server_proc, QLineEdit)
self.assertEqual(settings.get_config('Alignak', 'processes'),
under_test.server_proc.text())
self.assertIsInstance(under_test.server_port, QLineEdit)
self.assertEqual(
settings.get_config('Alignak', 'backend').split(':')[2],
under_test.server_port.text())
self.assertIsInstance(under_test.server_url, QLineEdit)
self.assertEqual(settings.get_config('Alignak', 'url'),
under_test.server_url.text())
self.assertIsInstance(under_test.webservice_url, QLineEdit)
self.assertEqual(settings.get_config('Alignak', 'webservice'),
under_test.webservice_url.text())
def test_log_to_backend(self):
"""Connection to Alignak-Backend"""
under_test = BackendClient()
connect = under_test.login(
settings.get_config('Alignak', 'username'),
settings.get_config('Alignak', 'password')
)
# Compare config url and app_backend
self.assertEquals(
under_test.backend.url_endpoint_root,
settings.get_config('Alignak', 'backend')
)
self.assertTrue(under_test.connected)
self.assertTrue(under_test.backend.authenticated)
self.assertTrue(connect)
# Assert on second connection, backend use token !
connect = under_test.login()
self.assertTrue(connect)
def initialize(self):
"""
Intialize Spy QWidget
"""
layout = QGridLayout()
self.setLayout(layout)
spy_icon = QLabel()
spy_pixmap = QPixmap(settings.get_image('spy'))
spy_icon.setPixmap(spy_pixmap)
spy_icon.setScaledContents(True)
spy_icon.setFixedSize(20, 20)
layout.addWidget(spy_icon, 0, 0, 1, 1)
layout.setAlignment(spy_icon, Qt.AlignRight)
spy_title = QLabel(_('Spy Hosts'))
spy_title.setObjectName('title')
spy_title.setMinimumHeight(40)
layout.addWidget(spy_title, 0, 1, 1, 1)
hint_lbl = QLabel('Click to refresh, double-click to stop spying')
hint_lbl.setObjectName('subtitle')
layout.addWidget(hint_lbl, 1, 0, 1, 1)
layout.setAlignment(hint_lbl, Qt.AlignCenter)
self.host_services_lbl.setObjectName('subtitle')
layout.addWidget(self.host_services_lbl, 1, 1, 1, 1)
layout.setAlignment(self.host_services_lbl, Qt.AlignCenter)
self.spy_list_widget.setDragDropMode(QAbstractItemView.DragDrop)
self.spy_list_widget.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.spy_list_widget.doubleClicked.connect(self.remove_event)
self.spy_list_widget.setAcceptDrops(True)
self.spy_list_widget.setWordWrap(True)
self.spy_list_widget.insertItem(0, self.get_hint_item())
self.spy_list_widget.item_dropped.connect(get_events_widget().remove_event)
self.spy_list_widget.clicked.connect(
lambda: self.manage_host_events(self.spy_list_widget.currentRow())
)
layout.addWidget(self.spy_list_widget, 2, 0, 1, 1)
self.host_list_widget.setObjectName('spy')
# self.host_list_widget.setMinimumWidth(500)
layout.addWidget(self.host_list_widget, 2, 1, 1, 1)
spy_interval = int(settings.get_config('Alignak-app', 'spy_interval')) * 1000
self.spy_timer.setInterval(spy_interval)
self.spy_timer.start()
self.spy_timer.timeout.connect(self.send_spy_events)
def test_default_view_is_problems(self):
"""Display Problems View by Default"""
settings.set_config('Alignak-app', 'problems', 'no')
under_test = AppQMainWindow()
data_manager.update_database('host', [])
data_manager.update_database('service', [])
init_event_widget()
self.assertEqual(-1, under_test.panel_widget.tab_widget.currentIndex())
under_test.initialize()
problems_index = under_test.panel_widget.get_tab_order().index('p')
self.assertFalse(
settings.get_config('Alignak-app', 'problems', boolean=True))
self.assertEqual(
problems_index,
under_test.panel_widget.tab_widget.indexOf(
under_test.panel_widget.problems_widget))
# Make "Problems" as default view
settings.set_config('Alignak-app', 'problems', 'yes')
under_test = AppQMainWindow()
init_event_widget()
under_test.initialize()
self.assertTrue(
settings.get_config('Alignak-app', 'problems', boolean=True))
self.assertEqual(
problems_index,
under_test.panel_widget.tab_widget.indexOf(
under_test.panel_widget.problems_widget))
# Reset settings
settings.set_config('Alignak-app', 'problems', 'no')
def test_get_endpoint_with_params_and_projection(self):
"""Backend GET"""
backend_test = BackendClient()
backend_test.login(
settings.get_config('Alignak', 'username'),
settings.get_config('Alignak', 'password')
)
# Get hosts states
test_projection = [
'name', 'alias'
]
test_params = {'where': json.dumps({'_is_template': False})}
under_test = backend_test.get('host', params=test_params, projection=test_projection)
self.assertTrue(under_test)
self.assertTrue(under_test['_items'])
self.assertTrue('name' in under_test['_items'][0])
self.assertTrue('alias' in under_test['_items'][0])
def test_query_history_data(self):
"""Query History Data"""
under_test = BackendClient()
under_test.login(settings.get_config('Alignak', 'username'),
settings.get_config('Alignak', 'password'))
from alignak_app.backend.datamanager import data_manager
under_test.query_history(self.hostname, self.host_id)
self.assertIsNotNone(data_manager.database['history'])
old_database = data_manager.database['history']
under_test.query_history()
self.assertIsNotNone(data_manager.database['history'])
# Assert that old history item has the same properties that the new one
self.assertTrue(old_database != data_manager.database['history'])
self.assertEqual(old_database[0].name,
data_manager.database['history'][0].name)
self.assertEqual(old_database[0].item_id,
data_manager.database['history'][0].item_id)
self.assertEqual(old_database[0].item_id, self.host_id)
def test_query_history_data(self):
"""Query History Data"""
under_test = BackendClient()
under_test.login(
settings.get_config('Alignak', 'username'),
settings.get_config('Alignak', 'password')
)
from alignak_app.backend.datamanager import data_manager
under_test.query_history(self.hostname, self.host_id)
self.assertIsNotNone(data_manager.database['history'])
old_database = data_manager.database['history']
under_test.query_history()
self.assertIsNotNone(data_manager.database['history'])
# Assert that old history item has the same properties that the new one
self.assertTrue(old_database != data_manager.database['history'])
self.assertEqual(old_database[0].name, data_manager.database['history'][0].name)
self.assertEqual(old_database[0].item_id, data_manager.database['history'][0].item_id)
self.assertEqual(old_database[0].item_id, self.host_id)
def test_default_view_is_problems(self):
"""Display Problems View by Default"""
settings.set_config('Alignak-app', 'problems', 'no')
under_test = AppQMainWindow()
data_manager.update_database('host', [])
data_manager.update_database('service', [])
init_event_widget()
self.assertEqual(-1, under_test.panel_widget.tab_widget.currentIndex())
under_test.initialize()
problems_index = under_test.panel_widget.get_tab_order().index('p')
self.assertFalse(settings.get_config('Alignak-app', 'problems', boolean=True))
self.assertEqual(
problems_index,
under_test.panel_widget.tab_widget.indexOf(under_test.panel_widget.problems_widget)
)
# Make "Problems" as default view
settings.set_config('Alignak-app', 'problems', 'yes')
under_test = AppQMainWindow()
init_event_widget()
under_test.initialize()
self.assertTrue(settings.get_config('Alignak-app', 'problems', boolean=True))
self.assertEqual(
problems_index,
under_test.panel_widget.tab_widget.indexOf(under_test.panel_widget.problems_widget)
)
# Reset settings
settings.set_config('Alignak-app', 'problems', 'no')
def accept_login(self):
"""
Accept Login or not if backend is connected
"""
username = str(self.username_line.text())
password = str(self.password_line.text())
# Set proxy only if in config
if not self.proxies and settings.get_config('Alignak', 'proxy'):
self.set_proxy_settings()
if app_backend.login(username, password, proxies=self.proxies):
self.accept()
else:
self.reject()
def initialize(self):
"""
Initialize QWidget
"""
self.setLayout(self.layout)
self.layout.setContentsMargins(0, 0, 0, 0)
self.get_host_resume_widget()
self.get_services_resume_widget()
self.update_dashboard()
update_dashboard = int(settings.get_config('Alignak-app', 'update_dashboard')) * 1000
self.refresh_timer.setInterval(update_dashboard)
self.refresh_timer.start()
self.refresh_timer.timeout.connect(self.update_dashboard)
def check_threads():
"""
Launch periodically threads
"""
# Cleaning threads who are finished
thread_manager.clean_threads()
# Launch or stop threads
if app_backend.connected:
thread_manager.launch_threads('low')
thread_manager.launch_threads('normal')
thread_manager.launch_threads('normal')
else:
logger.debug(
'Can\'t launch Request threads, App is not connected to backend [%s] !',
settings.get_config('Alignak', 'backend'))
thread_manager.stop_threads()
def initialize(self):
"""
Initialize QWidget
"""
layout = QGridLayout()
self.setLayout(layout)
layout.addWidget(self.get_service_icon_widget(), 0, 0, 1, 1)
layout.addWidget(self.get_actions_widget(), 0, 1, 1, 1)
layout.addWidget(self.get_last_check_widget(), 1, 0, 1, 2)
update_service = int(settings.get_config('Alignak-app', 'update_service')) * 1000
self.refresh_timer.setInterval(update_service)
self.refresh_timer.start()
self.refresh_timer.timeout.connect(self.periodic_refresh)
self.hide()
def initialize(self):
"""
Initialize QWidget
"""
layout = QGridLayout()
self.setLayout(layout)
layout.addWidget(self.get_service_icon_widget(), 0, 0, 1, 1)
layout.addWidget(self.get_actions_widget(), 0, 1, 1, 1)
layout.addWidget(self.get_last_check_widget(), 1, 0, 1, 2)
update_service = int(
settings.get_config('Alignak-app', 'update_service')) * 1000
self.refresh_timer.setInterval(update_service)
self.refresh_timer.start()
self.refresh_timer.timeout.connect(self.periodic_refresh)
self.hide()
def get_tab_order():
"""
Return tab order defined by user, else default order
:return: tab order of App
:rtype: list
"""
default_order = ['p', 'h', 's']
tab_order = settings.get_config('Alignak-app', 'tab_order').split(',')
try:
assert len(tab_order) == len(default_order)
for nb in default_order:
assert nb in tab_order
except AssertionError:
logger.error('Wrong "tab_order" value in config file %s', tab_order)
tab_order = default_order
return tab_order
def initialize(self):
"""
Initialize QWidget
"""
layout = QHBoxLayout()
self.setLayout(layout)
item_types = ['host', 'service', 'problem']
for item_type in item_types:
item_widget = self.get_item_type_widget(item_type, 0, 0)
layout.addWidget(item_widget)
self.update_labels()
update_livestate = int(settings.get_config('Alignak-app', 'update_livestate')) * 1000
self.timer.setInterval(update_livestate)
self.timer.start()
self.timer.timeout.connect(self.update_labels)
def initialize(self):
"""
Initialize QWidget
"""
layout = QGridLayout()
self.setLayout(layout)
# Add Qwidgets
layout.addWidget(self.get_host_icon_widget(), 0, 0, 2, 1)
layout.addWidget(self.get_last_check_widget(), 0, 1, 1, 1)
layout.addWidget(self.get_variables_widget(), 0, 2, 1, 1)
layout.addWidget(self.get_notes_output_widget(), 1, 1, 1, 2)
layout.addWidget(self.get_actions_widget(), 0, 3, 2, 1)
update_host = int(settings.get_config('Alignak-app', 'update_host')) * 1000
self.refresh_timer.setInterval(update_host)
self.refresh_timer.start()
self.refresh_timer.timeout.connect(self.update_host)
def get_settings_widget(self):
"""
Return the alignak settings QWidget
:return: settings QWidget
:rtype: QWidget
"""
server_widget = QWidget()
server_widget.setObjectName('dialog')
server_layout = QVBoxLayout(server_widget)
# Title
title_lbl = QLabel(_('Alignak Backend'))
title_lbl.setObjectName('itemtitle')
server_layout.addWidget(title_lbl)
server_layout.setAlignment(title_lbl, Qt.AlignTop)
# Description
desc_label = QLabel(
_('Here you can define alignak settings. Be sure to enter a valid address.')
)
desc_label.setWordWrap(True)
server_layout.addWidget(desc_label)
# Server URL
server_lbl = QLabel(_('Server'))
server_layout.addWidget(server_lbl)
self.server_url.setText(settings.get_config('Alignak', 'url'))
self.server_url.setPlaceholderText(_('alignak backend url...'))
self.server_url.setFixedHeight(25)
server_layout.addWidget(self.server_url)
# Server Port
port_lbl = QLabel(_('Port'))
server_layout.addWidget(port_lbl)
cur_port = settings.get_config('Alignak', 'backend').split(':')[2]
self.server_port.setText(cur_port)
self.server_port.setPlaceholderText(_('alignak backend port...'))
self.server_port.setFixedHeight(25)
server_layout.addWidget(self.server_port)
# Server Processes (displayed only for Unix platforms)
if 'win32' not in sys.platform:
process_lbl = QLabel(_('Processes'))
server_layout.addWidget(process_lbl)
cur_proc = settings.get_config('Alignak', 'processes')
self.server_proc.setText(cur_proc)
self.server_proc.setPlaceholderText(_('alignak backend processes...'))
self.server_proc.setFixedHeight(25)
server_layout.addWidget(self.server_proc)
# Web Service description
server_layout.addStretch(1)
webservice_lbl = QLabel(_('Web Service'))
webservice_lbl.setObjectName('itemtitle')
server_layout.addWidget(webservice_lbl)
ws_desc_lbl = QLabel(
_('Here you can define your alignak web service url, with port if needed')
)
ws_desc_lbl.setWordWrap(True)
server_layout.addWidget(ws_desc_lbl)
# Web Service URL
self.webservice_url.setText(settings.get_config('Alignak', 'webservice'))
self.webservice_url.setPlaceholderText(_('alignak webservice url...'))
self.webservice_url.setFixedHeight(25)
server_layout.addWidget(self.webservice_url)
# Valid Button
valid_btn = QPushButton(_('Valid'))
valid_btn.setObjectName('valid')
valid_btn.setMinimumHeight(30)
valid_btn.clicked.connect(self.accept)
server_layout.addWidget(valid_btn)
return server_widget
def initialize(self):
"""
Initialize QWidget
"""
self.update_status()
layout = QGridLayout()
self.setLayout(layout)
# Backend state
connected_title = QLabel(_('Backend API'))
connected_title.setObjectName('subtitle')
layout.addWidget(connected_title, 0, 0, 1, 1)
self.backend_connected.setFixedSize(16, 16)
self.backend_connected.setScaledContents(True)
self.backend_connected.setToolTip(_('Status of the backend API connection'))
layout.addWidget(self.backend_connected, 0, 1, 1, 1)
layout.setAlignment(self.backend_connected, Qt.AlignCenter)
# WS state
ws_title = QLabel(_('Web Service'))
ws_title.setObjectName('subtitle')
layout.addWidget(ws_title, 0, 2, 1, 1)
self.ws_connected.setFixedSize(16, 16)
self.ws_connected.setScaledContents(True)
self.ws_connected.setToolTip(_('Status of the Web Service connection'))
layout.addWidget(self.ws_connected, 0, 3, 1, 1)
layout.setAlignment(self.ws_connected, Qt.AlignCenter)
# Daemons state
daemons_title = QLabel(_('Alignak'))
daemons_title.setObjectName('subtitle')
layout.addWidget(daemons_title, 1, 0, 1, 1)
self.status_dialog.initialize()
self.update_status_btn(self.status_dialog.update_dialog())
self.status_btn.setFixedSize(32, 32)
self.status_btn.clicked.connect(self.show_status_dialog)
self.status_btn.setToolTip(_('Status of daemons connection'))
layout.addWidget(self.status_btn, 1, 1, 1, 1)
layout.setAlignment(self.status_btn, Qt.AlignCenter)
# User
user_lbl = QLabel(_('User'))
user_lbl.setObjectName('subtitle')
layout.addWidget(user_lbl, 1, 2, 1, 1)
self.profile_widget.initialize()
self.profile_btn.setIcon(QIcon(settings.get_image('user')))
self.profile_btn.setFixedSize(32, 32)
self.profile_btn.clicked.connect(self.show_user_widget)
self.profile_btn.setToolTip(_('View current user'))
layout.addWidget(self.profile_btn, 1, 3, 1, 1)
# Refresh timer
update_status = int(settings.get_config('Alignak-app', 'update_status')) * 1000
self.refresh_timer.setInterval(update_status)
self.refresh_timer.start()
self.refresh_timer.timeout.connect(self.update_status)
def create_logger(): # pragma: no cover
"""
Create the logger for Alignak-App
:return: the RootLogger of App
:rtype: logging.RootLogger
"""
root_logger = getLogger()
stdout_handler = None
if root_logger.handlers:
stdout_handler = root_logger.handlers[0]
# Define path and file for "file_handler"
if 'ALIGNAKAPP_LOG_DIR' in os.environ:
path = os.environ['ALIGNAKAPP_LOG_DIR']
elif 'ALIGNAKAPP_USR_DIR' in os.environ:
path = os.environ['ALIGNAKAPP_USR_DIR']
else:
path = tempfile.gettempdir()
if not os.access(path, os.W_OK):
print('Access denied for [%s], App will log in current directory !' % path)
path = '.'
os.environ['ALIGNAKAPP_LOG_DIR'] = path
filename = '%s.log' % settings.get_config('Log', 'filename')
if not os.path.isdir(path):
# noinspection PyBroadException
try: # pragma: no cover - not testable
os.makedirs(path)
except Exception:
print('Can\'t create log file in [%s], App will log in current directory !' % path)
path = '.'
formatter = Formatter(
fmt='[%(asctime)s]-%(name)12s: [%(levelname)s] %(message)s',
datefmt='%Y-%m-%d,%H:%M:%S'
)
# Create "file_handler"
file_handler = TimedRotatingFileHandler(
filename=os.path.join(path, filename),
when="D",
interval=1,
backupCount=6
)
file_handler.setLevel(DEBUG)
file_handler.setFormatter(formatter)
root_logger.addHandler(file_handler)
# Remove stdout handler to ensure logs are only in filehandler
root_logger.removeHandler(stdout_handler)
return root_logger
