osm_mon/dashboarder/backends/grafana.py

   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: glavado@whitestack.com or fbravo@whitestack.com
  22 ##
  23 import logging
  24 import requests
  25 import base64
  26 import json
  27 from osm_mon.core.config import Config
  28
  29 log = logging.getLogger(__name__)
  30
  31
  32 class GrafanaBackend:
  33     def __init__(self, config: Config):
  34         self.conf = config
  35         self.url = config.get("grafana", "url")
  36         grafana_user = config.get("grafana", "user")
  37         grafana_password = config.get("grafana", "password")
  38         self.headers = {
  39             "content-type": "application/json",
  40             "authorization": "Basic %s"
  41             % base64.b64encode(
  42                 (grafana_user + ":" + grafana_password).encode("utf-8")
  43             ).decode(),
  44         }
  45
  46     def get_all_dashboard_uids(self):
  47         # Gets only dashboards that were automated by OSM (with tag 'osm_automated')
  48         response = requests.request(
  49             "GET", self.url + "/api/search?tag=osm_automated", headers=self.headers
  50         )
  51         dashboards = response.json()
  52         dashboard_uids = []
  53         for dashboard in dashboards:
  54             dashboard_uids.append(dashboard["uid"])
  55         log.debug("Searching for all dashboard uids: %s", dashboard_uids)
  56         return dashboard_uids
  57
  58     def get_all_datasource_names(self, datasource_name_substr):
  59         # Gets only dashboards that were created for prom-operator
  60         response = requests.request(
  61             "GET", self.url + "/api/datasources", headers=self.headers
  62         )
  63         datasources = response.json()
  64         datasource_names = []
  65         for datasource in datasources:
  66             if datasource["name"].startswith(datasource_name_substr):
  67                 datasource_names.append(datasource["name"])
  68         log.debug("Searching for all datasource names: %s", datasource_names)
  69         return datasource_names
  70
  71     def get_dashboard_status(self, uid):
  72         response = requests.request(
  73             "GET", self.url + "/api/dashboards/uid/" + uid, headers=self.headers
  74         )
  75         log.debug("Searching for dashboard result: %s", response.text)
  76         return response
  77
  78     def create_dashboard(self, uid, name, json_file, project_name=None, datasource_name=None):
  79         try:
  80             with open(json_file) as f:
  81                 dashboard_data = f.read()
  82
  83             dashboard_data = dashboard_data.replace("OSM_ID", uid).replace(
  84                 "OSM_NAME", name
  85             )
  86             if datasource_name:
  87                 dashboard_data = dashboard_data.replace("OSM_DATASOURCE_NAME", datasource_name)
  88             dashboard_json_data = json.loads(dashboard_data)
  89             # Get folder id
  90             if project_name:
  91                 folder_name = project_name
  92             else:
  93                 folder_name = name
  94             response_folder_id = requests.request(
  95                 "GET",
  96                 self.url + "/api/folders/{}".format(folder_name),
  97                 headers=self.headers,
  98             )
  99             if response_folder_id.status_code == 200:
 100                 folder_id = json.loads(response_folder_id.text)["id"]
 101                 dashboard_json_data["folderId"] = folder_id
 102                 dashboard_json_data["overwrite"] = False
 103
 104             response = self.send_request_for_creating_dashboard(dashboard_json_data)
 105
 106             # Admin dashboard will be created if already exists. Rest will remain same.
 107             if json.loads(response.text).get("status") == "name-exists":
 108                 # Delete any previous project-admin dashboard if it already exist.
 109                 if name == "admin":
 110                     self.delete_admin_dashboard()
 111                     response = self.send_request_for_creating_dashboard(
 112                         dashboard_json_data
 113                     )
 114                 else:
 115                     return
 116
 117             # Get team id
 118             if project_name is not None:
 119                 name = project_name
 120             response_team = requests.request(
 121                 "GET",
 122                 self.url + "/api/teams/search?name={}".format(name),
 123                 headers=self.headers,
 124             )
 125
 126             # Remove default permissions of admin user's dashboard so that it is not visible to non-admin users
 127             if len(json.loads(response_team.text)["teams"]) == 0:
 128                 # As team information is not available so it is admin user
 129                 dahboard_id = json.loads(response.text)["id"]
 130                 requests.request(
 131                     "POST",
 132                     self.url + "/api/dashboards/id/{}/permissions".format(dahboard_id),
 133                     headers=self.headers,
 134                 )
 135
 136             log.info("Dashboard %s is created in Grafana", name)
 137             return response
 138         except Exception:
 139             log.exception("Exception processing message: ")
 140
 141     def create_datasource(self, datasource_name, datasource_type, datasource_url):
 142         try:
 143             datasource_data = {
 144                 "name": datasource_name,
 145                 "type": datasource_type,
 146                 "url": datasource_url,
 147                 "access": "proxy",
 148                 "readOnly": False,
 149                 "basicAuth": False
 150             }
 151             response = requests.request(
 152                 "POST",
 153                 self.url + "/api/datasources",
 154                 data=json.dumps(datasource_data),
 155                 headers=self.headers,
 156             )
 157             log.info("Datasource %s is created in Grafana", datasource_name)
 158             log.info("************* response: {}".format(response.__dict__))
 159             return response
 160         except Exception:
 161             log.exception("Exception processing request for creating datasource: ")
 162
 163     def send_request_for_creating_dashboard(self, dashboard_data):
 164         response = requests.request(
 165             "POST",
 166             self.url + "/api/dashboards/db/",
 167             data=json.dumps(dashboard_data),
 168             headers=self.headers,
 169         )
 170         return response
 171
 172     def delete_dashboard(self, uid):
 173         response = requests.request(
 174             "DELETE", self.url + "/api/dashboards/uid/" + uid, headers=self.headers
 175         )
 176         log.debug("Dashboard %s deleted from Grafana", uid)
 177         return response
 178
 179     def delete_datasource(self, datasource_name):
 180         response = requests.request(
 181             "DELETE", self.url + "/api/datasources/name/" + datasource_name, headers=self.headers
 182         )
 183         log.debug("Datasource %s deleted from Grafana", datasource_name)
 184         return response
 185
 186     def delete_admin_dashboard(self):
 187         requests.request(
 188             "DELETE",
 189             self.url + "/api/dashboards/db/osm-project-status-admin",
 190             headers=self.headers,
 191         )
 192         log.debug("Dashboard osm-project-status-admin deleted from Grafana")
 193
 194     def create_grafana_users(self, user):
 195         email = "{}@osm.etsi.org".format(user)
 196         user_payload = {
 197             "name": user,
 198             "email": email,
 199             "login": user,
 200             "password": user,
 201         }
 202         response_users = requests.request(
 203             "POST",
 204             self.url + "/api/admin/users/",
 205             json=user_payload,
 206             headers=self.headers,
 207         )
 208         json_data = json.loads(response_users.text)
 209         url = "/api/org/users/{}/".format(json_data["id"])
 210         permission_payload = {
 211             "role": "Editor",
 212         }
 213         requests.request(
 214             "PATCH", self.url + url, json=permission_payload, headers=self.headers
 215         )
 216         log.info("New user %s created in Grafana", user)
 217         return response_users
 218
 219     # Get Grafana users
 220     def get_grafana_users(self):
 221         response_users = requests.request(
 222             "GET",
 223             self.url + "/api/users",
 224             headers=self.headers,
 225         )
 226         user_list = []
 227         users = json.loads(response_users.text)
 228         for user in users:
 229             if user["name"] and user["name"] != "admin":
 230                 user_list.append(user["name"])
 231         return user_list
 232
 233     # Create Grafana team with member
 234     def create_grafana_teams_members(
 235         self, project_name, user_name, is_admin, proj_list
 236     ):
 237         # Check if user exist in Grafana
 238         user_response = requests.request(
 239             "GET",
 240             self.url + "/api/users/lookup?loginOrEmail={}".format(user_name),
 241             headers=self.headers,
 242         )
 243         user_obj = json.loads(user_response.text)
 244         if user_response.status_code != 200:
 245             user_response = self.create_grafana_users(user_name)
 246             user_obj = json.loads(user_response.text)
 247
 248         user_id = user_obj["id"]
 249
 250         # Get teams for user
 251         team_objs = requests.request(
 252             "GET",
 253             self.url + "/api/users/{}/teams".format(user_id),
 254             headers=self.headers,
 255         )
 256         team_obj = json.loads(team_objs.text)
 257         team_list = []
 258         if len(team_obj):
 259             for team in team_obj:
 260                 team_list.append(team["name"])
 261
 262         proj_unlink = set(team_list) - set(proj_list)
 263         for prj in proj_unlink:
 264             response_team = requests.request(
 265                 "GET",
 266                 self.url + "/api/teams/search?name={}".format(prj),
 267                 headers=self.headers,
 268             )
 269             team_id = json.loads(response_team.text)["teams"][0]["id"]
 270             requests.request(
 271                 "DELETE",
 272                 self.url + "/api/teams/{}/members/{}".format(team_id, user_id),
 273                 headers=self.headers,
 274             )
 275         if project_name != "admin":
 276             # Add member to team
 277             response_team = requests.request(
 278                 "GET",
 279                 self.url + "/api/teams/search?name={}".format(project_name),
 280                 headers=self.headers,
 281             )
 282
 283             # Search if team in Grafana corresponding to the project already exists
 284             if not json.loads(response_team.text)["teams"]:
 285                 self.create_grafana_teams(project_name)
 286                 response_team = requests.request(
 287                     "GET",
 288                     self.url + "/api/teams/search?name={}".format(project_name),
 289                     headers=self.headers,
 290                 )
 291             team_id = json.loads(response_team.text)["teams"][0]["id"]
 292             if project_name not in team_list:
 293                 # Create a team in Grafana corresponding to the project as it doesn't exist
 294                 member_payload = {"userId": user_id}
 295                 requests.request(
 296                     "POST",
 297                     self.url + "/api/teams/{}/members".format(team_id),
 298                     json=member_payload,
 299                     headers=self.headers,
 300                 )
 301         # Check if user role or project name is admin
 302         if is_admin or project_name == "admin":
 303             # Give admin righsts to user
 304             url = "/api/org/users/{}/".format(user_id)
 305             permission_payload = {
 306                 "role": "Admin",
 307             }
 308             requests.request(
 309                 "PATCH", self.url + url, json=permission_payload, headers=self.headers
 310             )
 311             log.info("User %s is assigned Admin permission", user_name)
 312         else:
 313             # Give editor rights to user
 314             url = "/api/org/users/{}/".format(user_id)
 315             permission_payload = {
 316                 "role": "Editor",
 317             }
 318             requests.request(
 319                 "PATCH", self.url + url, json=permission_payload, headers=self.headers
 320             )
 321             log.info("User %s is assigned Editor permission", user_name)
 322
 323     # Create team in Grafana
 324     def create_grafana_teams(self, team_name):
 325         team_payload = {
 326             "name": team_name,
 327         }
 328         requests.request(
 329             "POST", self.url + "/api/teams", json=team_payload, headers=self.headers
 330         )
 331         log.info("New team %s created in Grafana", team_name)
 332
 333     # Create folder in Grafana
 334     def create_grafana_folders(self, folder_name):
 335         folder_payload = {"uid": folder_name, "title": folder_name}
 336         requests.request(
 337             "POST", self.url + "/api/folders", json=folder_payload, headers=self.headers
 338         )
 339         log.info("Dashboard folder %s created", folder_name)
 340
 341         response_team = requests.request(
 342             "GET",
 343             self.url + "/api/teams/search?name={}".format(folder_name),
 344             headers=self.headers,
 345         )
 346         # Create team if it doesn't already exists
 347         if len(json.loads(response_team.text)["teams"]) == 0:
 348             self.create_grafana_teams(folder_name)
 349             response_team = requests.request(
 350                 "GET",
 351                 self.url + "/api/teams/search?name={}".format(folder_name),
 352                 headers=self.headers,
 353             )
 354         # Assign required permission to the team's folder
 355         team_id = json.loads(response_team.text)["teams"][0]["id"]
 356         permission_data = {
 357             "items": [
 358                 {"teamId": team_id, "permission": 2},
 359             ]
 360         }
 361         requests.request(
 362             "POST",
 363             self.url + "/api/folders/{}/permissions".format(folder_name),
 364             json=permission_data,
 365             headers=self.headers,
 366         )
 367
 368     # delete user from grafana
 369     def delete_grafana_users(self, user_name):
 370         # Get user id
 371         response_id = requests.request(
 372             "GET",
 373             self.url + "/api/users/lookup?loginOrEmail={}".format(user_name),
 374             headers=self.headers,
 375         )
 376         try:
 377             user_id = json.loads(response_id.text)["id"]
 378         except Exception:
 379             log.exception("Exception processing message: ")
 380         # Delete user
 381         response = requests.request(
 382             "DELETE",
 383             self.url + "/api/admin/users/{}".format(user_id),
 384             headers=self.headers,
 385         )
 386         log.info("User %s deleted in Grafana", user_name)
 387         return response
 388
 389     # delete team from grafana
 390     def delete_grafana_team(self, project_name):
 391         # Delete Grafana folder
 392         requests.request(
 393             "DELETE",
 394             self.url + "/api/folders/{}".format(project_name),
 395             headers=self.headers,
 396         )
 397         # Delete Grafana team
 398         team_obj = requests.request(
 399             "GET",
 400             self.url + "/api/teams/search?name={}".format(project_name),
 401             headers=self.headers,
 402         )
 403         team_id = json.loads(team_obj.text)["teams"][0]["id"]
 404         response = requests.request(
 405             "DELETE", self.url + "/api/teams/{}".format(team_id), headers=self.headers
 406         )
 407         log.info("Team %s deleted in Grafana", project_name)
 408         return response
 409
 410     # update grafana team
 411     def update_grafana_teams(self, project_new_name, project_old_name):
 412         team_obj = requests.request(
 413             "GET",
 414             self.url + "/api/teams/search?name={}".format(project_old_name),
 415             headers=self.headers,
 416         )
 417         team_id = json.loads(team_obj.text)["teams"][0]["id"]
 418         data = {
 419             "name": project_new_name,
 420         }
 421         response = requests.request(
 422             "PUT",
 423             self.url + "/api/teams/{}".format(team_id),
 424             json=data,
 425             headers=self.headers,
 426         )
 427         log.info("Grafana team updated %s", response.text)
 428         return response
 429
 430     # remove member from grafana team
 431     def remove_grafana_team_member(self, user_name, project_data):
 432         # Get user id
 433         response_id = requests.request(
 434             "GET",
 435             self.url + "/api/users/lookup?loginOrEmail={}".format(user_name),
 436             headers=self.headers,
 437         )
 438         user_id = json.loads(response_id.text)["id"]
 439         for project in project_data:
 440             # Get team id
 441             team_obj = requests.request(
 442                 "GET",
 443                 self.url + "/api/teams/search?name={}".format(project["project"]),
 444                 headers=self.headers,
 445             )
 446             team_id = json.loads(team_obj.text)["teams"][0]["id"]
 447             response = requests.request(
 448                 "DELETE",
 449                 self.url + "/api/teams/{}/members/{}".format(team_id, user_id),
 450                 headers=self.headers,
 451             )
 452         return response