Coverage for osm_mon/server/server.py: 0%

1# -*- coding: utf-8 -*- 

2 

3# Copyright 2018 Whitestack, LLC 

4# ************************************************************* 

5 

6# This file is part of OSM Monitoring module 

7# All Rights Reserved to Whitestack, LLC 

8 

9# Licensed under the Apache License, Version 2.0 (the "License"); you may 

10# not use this file except in compliance with the License. You may obtain 

11# a copy of the License at 

12 

13# http://www.apache.org/licenses/LICENSE-2.0 

14 

15# Unless required by applicable law or agreed to in writing, software 

16# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 

17# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the 

18# License for the specific language governing permissions and limitations 

19# under the License. 

20# For those usages not covered by the Apache License, Version 2.0 please 

21# contact: bdiaz@whitestack.com or glavado@whitestack.com 

22## 

23""" 

24MON component in charge of CRUD operations for vim_accounts and alarms. It uses the message bus to communicate. 

25""" 

26import asyncio 

27import json 

28import logging 

29import time 

30 

31from osm_mon.core.config import Config 

32from osm_mon.core.message_bus_client import MessageBusClient 

33from osm_mon.core.response import ResponseBuilder 

34from osm_mon.server.service import ServerService 

35 

36log = logging.getLogger(__name__) 

37 

38 

39class Server: 

40 def __init__(self, config: Config): 

41 self.conf = config 

42 self.msg_bus = MessageBusClient(config) 

43 self.service = ServerService(config) 

44 self.service.populate_prometheus() 

45 

46 def run(self): 

47 asyncio.run(self.start()) 

48 

49 async def start(self, wait_time=5): 

50 topics = ["alarm_request"] 

51 while True: 

52 try: 

53 await self.msg_bus.aioread(topics, self._process_msg) 

54 break 

55 except Exception as e: 

56 # Failed to subscribe to kafka topic 

57 log.error("Error when subscribing to topic(s) %s", str(topics)) 

58 log.exception("Exception %s", str(e)) 

59 # Wait for some time for kaka to stabilize and then reattempt to subscribe again 

60 time.sleep(wait_time) 

61 log.info("Retrying to subscribe the kafka topic(s) %s", str(topics)) 

62 

63 async def _process_msg(self, topic, key, values): 

64 log.info("Message arrived: %s", values) 

65 try: 

66 if topic == "alarm_request": 

67 if key == "create_alarm_request": 

68 alarm_details = values["alarm_create_request"] 

69 cor_id = alarm_details["correlation_id"] 

70 response_builder = ResponseBuilder() 

71 try: 

72 alarm = self.service.create_alarm( 

73 alarm_details["alarm_name"], 

74 alarm_details["threshold_value"], 

75 alarm_details["operation"].lower(), 

76 alarm_details["severity"].lower(), 

77 alarm_details["statistic"].lower(), 

78 alarm_details["metric_name"], 

79 alarm_details["action"], 

80 alarm_details["tags"], 

81 ) 

82 response = response_builder.generate_response( 

83 "create_alarm_response", 

84 cor_id=cor_id, 

85 status=True, 

86 alarm_id=alarm.uuid, 

87 ) 

88 except Exception: 

89 log.exception("Error creating alarm: ") 

90 response = response_builder.generate_response( 

91 "create_alarm_response", 

92 cor_id=cor_id, 

93 status=False, 

94 alarm_id=None, 

95 ) 

96 await self._publish_response( 

97 "alarm_response_" + str(cor_id), 

98 "create_alarm_response", 

99 response, 

100 ) 

101 

102 if key == "delete_alarm_request": 

103 alarm_details = values["alarm_delete_request"] 

104 alarm_uuid = alarm_details["alarm_uuid"] 

105 response_builder = ResponseBuilder() 

106 cor_id = alarm_details["correlation_id"] 

107 try: 

108 self.service.delete_alarm(alarm_uuid) 

109 response = response_builder.generate_response( 

110 "delete_alarm_response", 

111 cor_id=cor_id, 

112 status=True, 

113 alarm_id=alarm_uuid, 

114 ) 

115 except Exception: 

116 log.exception("Error deleting alarm: ") 

117 response = response_builder.generate_response( 

118 "delete_alarm_response", 

119 cor_id=cor_id, 

120 status=False, 

121 alarm_id=alarm_uuid, 

122 ) 

123 await self._publish_response( 

124 "alarm_response_" + str(cor_id), 

125 "delete_alarm_response", 

126 response, 

127 ) 

128 

129 except Exception: 

130 log.exception("Exception processing message: ") 

131 

132 async def _publish_response(self, topic: str, key: str, msg: dict): 

133 log.info( 

134 "Sending response %s to topic %s with key %s", json.dumps(msg), topic, key 

135 ) 

136 await self.msg_bus.aiowrite(topic, key, msg)