Webservice for vRealize Operations (vROPs) to post/notify alarms details.
"""
+from osm_mon.core.settings import Config
+
__author__ = "Arpita Kate"
__date__ = "$15-Sept-2017 16:09:29$"
__version__ = '0.1'
-
-from bottle import (ServerAdapter, route, run, server_names, redirect, default_app,
- request, response, template, debug, TEMPLATE_PATH , static_file)
-from socket import getfqdn
-from datetime import datetime
-from xml.etree import ElementTree as ET
+import json
import logging
import os
-import json
import sys
+from datetime import datetime
+from socket import getfqdn
+
import requests
-sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', '..', '..','..'))
-from osm_mon.core.message_bus.producer import KafkaProducer
-#from core.message_bus.producer import KafkaProducer
+from bottle import (ServerAdapter, route, run, server_names, default_app,
+ request, response)
+
+sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', '..', '..', '..'))
+from osm_mon.core.message_bus.producer import Producer
+
+# from core.message_bus.producer import KafkaProducer
sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', '..', '..'))
from osm_mon.core.database import DatabaseManager
from cherrypy.wsgiserver import CherryPyWSGIServer as WSGIServer
from cherrypy.wsgiserver.ssl_pyopenssl import pyOpenSSLAdapter
-#Set Constants
+# Set Constants
BASE_DIR = os.path.dirname(os.path.dirname(__file__))
CERT_DIR = os.path.join(BASE_DIR, "SSL_certificate")
certificate_name = getfqdn() + ".cert"
key_name = getfqdn() + ".key"
CERTIFICATE = os.path.join(CERT_DIR, certificate_name)
KEY = os.path.join(CERT_DIR, key_name)
-#CERTIFICATE = os.path.join(CERT_DIR, "www.vrops_webservice.com.cert")
-#KEY = os.path.join(CERT_DIR, "www.vrops_webservice.com.key")
+# CERTIFICATE = os.path.join(CERT_DIR, "www.vrops_webservice.com.cert")
+# KEY = os.path.join(CERT_DIR, "www.vrops_webservice.com.key")
CONFIG_FILE = os.path.join(BASE_DIR, '../vrops_config.xml')
-#Severity Mapping from vROPs to OSM
+# Severity Mapping from vROPs to OSM
VROPS_SEVERITY_TO_OSM_MAPPING = {
- "ALERT_CRITICALITY_LEVEL_CRITICAL":"CRITICAL",
- "ALERT_CRITICALITY_LEVEL_WARNING":"WARNING",
- "ALERT_CRITICALITY_LEVEL_IMMEDIATE":"MAJOR",
- "ALERT_CRITICALITY_LEVEL_INFO":"INDETERMINATE",
- "ALERT_CRITICALITY_LEVEL_AUTO":"INDETERMINATE",
- "ALERT_CRITICALITY_LEVEL_UNKNOWN":"INDETERMINATE",
- "ALERT_CRITICALITY_LEVEL_NONE":"INDETERMINATE"
- }
-
-#Set logger
-logger = logging.getLogger('vROPs_Webservice')
-formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-hdlr = logging.FileHandler(os.path.join(BASE_DIR,"vrops_webservice.log"))
-hdlr.setFormatter(formatter)
-logger.addHandler(hdlr)
-logger.setLevel(logging.DEBUG)
+ "ALERT_CRITICALITY_LEVEL_CRITICAL": "CRITICAL",
+ "ALERT_CRITICALITY_LEVEL_WARNING": "WARNING",
+ "ALERT_CRITICALITY_LEVEL_IMMEDIATE": "MAJOR",
+ "ALERT_CRITICALITY_LEVEL_INFO": "INDETERMINATE",
+ "ALERT_CRITICALITY_LEVEL_AUTO": "INDETERMINATE",
+ "ALERT_CRITICALITY_LEVEL_UNKNOWN": "INDETERMINATE",
+ "ALERT_CRITICALITY_LEVEL_NONE": "INDETERMINATE"
+}
+
+# Set logger
+cfg = Config.instance()
+logging.basicConfig(stream=sys.stdout,
+ format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+ datefmt='%m/%d/%Y %I:%M:%S %p',
+ level=logging.getLevelName(cfg.OSMMON_LOG_LEVEL))
+
+logger = logging.getLogger(__name__)
def format_datetime(str_date):
date_fromat = "%Y-%m-%dT%H:%M:%S"
formated_datetime = None
try:
- datetime_obj = datetime.fromtimestamp(float(str_date)/1000.)
+ datetime_obj = datetime.fromtimestamp(float(str_date) / 1000.)
formated_datetime = datetime_obj.strftime(date_fromat)
except Exception as exp:
logger.error('Exception: {} occured while converting date {} into format {}'.format(
- exp,str_date, date_fromat))
+ exp, str_date, date_fromat))
return formated_datetime
+
def get_alarm_config(alarm_name):
"""
Method to get configuration parameters
"""
vim_account = {}
database_manager = DatabaseManager()
- vim_account_details = database_manager.get_credentials_for_alarm_name(alarm_name,'VMware')
+ alarm = database_manager.get_alarm(alarm_name, 'VMware')
+ vim_account_details = alarm.credentials
try:
if vim_account_details is not None:
vim_account['name'] = vim_account_details.name
vim_account['vim_tenant_name'] = vim_account_details.tenant_name
vim_account['vim_type'] = vim_account_details.type
- vim_account['vim_uuid'] = vim_account_details._id
+ vim_account['vim_uuid'] = vim_account_details.uuid
vim_account['vim_url'] = vim_account_details.url
vim_account['org_user'] = vim_account_details.user
vim_account['org_password'] = vim_account_details.password
- vim_config = json.loads(vim_account_details.config)
+ vim_config = json.loads(vim_account_details.config)
vim_account['tenant_id'] = vim_config['tenant_id']
vim_account['admin_username'] = vim_config['admin_username']
vim_account['admin_password'] = vim_config['admin_password']
alarm defination ID
"""
alarm_definationID = None
- if alarm_instance_uuid :
+ if alarm_instance_uuid:
try:
- #access_config = get_alarm_config()
+ # access_config = get_alarm_config()
headers = {'Accept': 'application/json'}
- api_url = '{}/suite-api/api/alerts/{}'\
- .format(access_config.get('vrops_site'), alarm_instance_uuid)
+ api_url = '{}/suite-api/api/alerts/{}' \
+ .format(access_config.get('vrops_site'), alarm_instance_uuid)
api_response = requests.get(api_url,
- auth=(access_config.get('vrops_user'),\
+ auth=(access_config.get('vrops_user'),
access_config.get('vrops_password')),
- verify = False,
- headers = headers
+ verify=False,
+ headers=headers
)
- if api_response.status_code == 200:
+ if api_response.status_code == 200:
data = api_response.json()
if data.get("alertDefinitionId") is not None:
alarm_definationID = '-'.join(data.get("alertDefinitionId").split('-')[1:])
else:
- logger.error("Failed to get alert definition ID for alarm {}"\
+ logger.error("Failed to get alert definition ID for alarm {}"
.format(alarm_instance_uuid))
except Exception as exp:
- logger.error("Exception occured while getting alert definition ID for alarm : {}"\
- .format(exp, alarm_instance_uuid))
+ logger.error("Exception occured while getting alert definition ID for alarm : {}"
+ .format(exp, alarm_instance_uuid))
return alarm_definationID
Returns:
response code
"""
- logger.info("Request:{} from:{} {} {} "\
+ logger.info("Request:{} from:{} {} {} " \
.format(request, request.remote_addr, request.method, request.url))
response.headers['Content-Type'] = 'application/json'
try:
postdata = json.loads(request.body.read())
notify_details = {}
vim_access_config = get_alarm_config(postdata.get('alertName'))
- #Parse noditfy data
- notify_details['vim_uuid'] = vim_access_config.get('vim_uuid')
- notify_details['alarm_uuid'] = get_alarm_definationID(postdata.get('alertId'),\
+ # Parse notify data
+ notify_details['vim_uuid'] = vim_access_config.get('vim_uuid')
+ notify_details['alarm_uuid'] = get_alarm_definationID(postdata.get('alertId'),
vim_access_config)
notify_details['description'] = postdata.get('info')
notify_details['alarm_instance_uuid'] = alarmID
notify_details['resource_uuid'] = '-'.join(postdata.get('alertName').split('-')[1:])
- notify_details['tenant_uuid'] = vim_access_config.get('tenant_id')
+ notify_details['tenant_uuid'] = vim_access_config.get('tenant_id')
notify_details['vim_type'] = "VMware"
- notify_details['severity'] = VROPS_SEVERITY_TO_OSM_MAPPING.get(postdata.get('criticality'),\
+ notify_details['severity'] = VROPS_SEVERITY_TO_OSM_MAPPING.get(postdata.get('criticality'),
'INDETERMINATE')
notify_details['status'] = postdata.get('status')
if postdata.get('startDate'):
alarm_details = {'schema_version': 1.0,
'schema_type': "notify_alarm",
'notify_details': notify_details
- }
+ }
alarm_data = json.dumps(alarm_details)
logger.info("Alarm details: {}".format(alarm_data))
- #Publish Alarm details
- kafkaMsgProducer = KafkaProducer("alarm_response")
- kafkaMsgProducer.publish(topic='alarm_response', key='notify_alarm', value=alarm_data)
+ # Publish Alarm details
+ producer = Producer()
+ producer.send(topic='alarm_response', key=notify_alarm, value=alarm_data)
+ producer.flush()
- #return 201 on Success
+ # return 201 on Success
response.status = 201
except Exception as exp:
logger.error('Exception: {} occured while notifying alarm {}.'.format(exp, alarmID))
- #return 500 on Error
+ # return 500 on Error
response.status = 500
return response
server.ssl_adapter = pyOpenSSLAdapter(
certificate=CERTIFICATE,
private_key=KEY,
- # certificate_chain="intermediate_cert.crt"
+ # certificate_chain="intermediate_cert.crt"
)
try:
if __name__ == "__main__":
- #Start SSL Web Service
+ # Start SSL Web Service
logger.info("Start vROPs Web Service")
app = default_app()
server_names['sslwebserver'] = SSLWebServer
- run(app=app,host=getfqdn(), port=8080, server='sslwebserver')
+ run(app=app, host=getfqdn(), port=8080, server='sslwebserver')
projects / osm / MON.git / blobdiff