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" % base64.b64encode(
  41                 (grafana_user + ":" + grafana_password).encode("utf-8")).decode()
  42         }
  43
  44     def get_all_dashboard_uids(self):
  45         # Gets only dashboards that were automated by OSM (with tag 'osm_automated')
  46         response = requests.request("GET", self.url + "/api/search?tag=osm_automated", headers=self.headers)
  47         dashboards = response.json()
  48         dashboard_uids = []
  49         for dashboard in dashboards:
  50             dashboard_uids.append(dashboard['uid'])
  51         log.debug("Searching for all dashboard uids: %s", dashboard_uids)
  52         return dashboard_uids
  53
  54     def get_dashboard_status(self, uid):
  55         response = requests.request("GET", self.url + "/api/dashboards/uid/" + uid, headers=self.headers)
  56         log.debug("Searching for dashboard result: %s", response.text)
  57         return response
  58
  59     def create_dashboard(self, uid, name, json_file, project_name=None):
  60         try:
  61             with open(json_file) as f:
  62                 dashboard_data = f.read()
  63
  64             dashboard_data = dashboard_data.replace('OSM_ID', uid).replace('OSM_NAME', name)
  65             dashboard_json_data = json.loads(dashboard_data)
  66             # Get folder id
  67             if project_name:
  68                 folder_name = project_name
  69             else:
  70                 folder_name = name
  71             response_folder_id = requests.request(
  72                 "GET", self.url + "/api/folders/{}".format(folder_name), headers=self.headers)
  73             if response_folder_id.status_code == 200:
  74                 folder_id = json.loads(response_folder_id.text)["id"]
  75                 dashboard_json_data["folderId"] = folder_id
  76                 dashboard_json_data["overwrite"] = False
  77
  78             response = self.send_request_for_creating_dashboard(dashboard_json_data)
  79
  80             # Admin dashboard will be created if already exists. Rest will remain same.
  81             if json.loads(response.text).get("status") == "name-exists":
  82                 # Delete any previous project-admin dashboard if it already exist.
  83                 if name == 'admin':
  84                     self.delete_admin_dashboard()
  85                     response = self.send_request_for_creating_dashboard(dashboard_json_data)
  86                 else:
  87                     return
  88
  89             # Get team id
  90             if project_name is not None:
  91                 name = project_name
  92             response_team = requests.request(
  93                 "GET", self.url + "/api/teams/search?name={}".format(name), headers=self.headers)
  94
  95             # Remove default permissions of admin user's dashboard so that it is not visible to non-admin users
  96             if len(json.loads(response_team.text)["teams"]) == 0:
  97                 # As team information is not available so it is admin user
  98                 dahboard_id = json.loads(response.text)["id"]
  99                 requests.request(
 100                     "POST", self.url + "/api/dashboards/id/{}/permissions".format(dahboard_id),
 101                     headers=self.headers)
 102
 103             log.info("Dashboard %s is created in Grafana", name)
 104             return response
 105         except Exception:
 106             log.exception("Exception processing message: ")
 107
 108     def send_request_for_creating_dashboard(self, dashboard_data):
 109         response = requests.request(
 110             "POST", self.url + "/api/dashboards/db/", data=json.dumps(dashboard_data), headers=self.headers)
 111         return response
 112
 113     def delete_dashboard(self, uid):
 114         response = requests.request("DELETE", self.url + "/api/dashboards/uid/" + uid, headers=self.headers)
 115         log.debug("Dashboard %s deleted from Grafana", uid)
 116         return response
 117
 118     def delete_admin_dashboard(self):
 119         requests.request(
 120             "DELETE", self.url + "/api/dashboards/db/osm-project-status-admin", headers=self.headers)
 121         log.debug("Dashboard osm-project-status-admin deleted from Grafana")
 122
 123     def create_grafana_users(self, user):
 124         email = "{}@osm.etsi.org".format(user)
 125         user_payload = {
 126             "name": user,
 127             "email": email,
 128             "login": user,
 129             "password": user,
 130         }
 131         response_users = requests.request("POST", self.url + "/api/admin/users/", json=user_payload,
 132                                           headers=self.headers)
 133         json_data = json.loads(response_users.text)
 134         url = "/api/org/users/{}/".format(json_data["id"])
 135         permission_payload = {"role": "Editor", }
 136         requests.request("PATCH", self.url + url, json=permission_payload, headers=self.headers)
 137         log.info("New user %s created in Grafana", user)
 138         return response_users
 139
 140     # Create Grafana team with member
 141     def create_grafana_teams_members(self, project_name, user_name, is_admin, proj_list):
 142         # Check if user exist in Grafana
 143         user_response = requests.request("GET", self.url + "/api/users/lookup?loginOrEmail={}".format(user_name),
 144                                          headers=self.headers)
 145         user_obj = json.loads(user_response.text)
 146         if user_response.status_code != 200:
 147             user_response = self.create_grafana_users(user_name)
 148             user_obj = json.loads(user_response.text)
 149
 150         user_id = user_obj["id"]
 151
 152         # Get teams for user
 153         team_objs = requests.request("GET", self.url + "/api/users/{}/teams".format(user_id), headers=self.headers)
 154         team_obj = json.loads(team_objs.text)
 155         team_list = []
 156         if len(team_obj):
 157             for team in team_obj:
 158                 team_list.append(team["name"])
 159
 160         proj_unlink = set(team_list) - set(proj_list)
 161         for prj in proj_unlink:
 162             response_team = requests.request("GET", self.url + "/api/teams/search?name={}".format(prj),
 163                                              headers=self.headers)
 164             team_id = json.loads(response_team.text)["teams"][0]["id"]
 165             requests.request("DELETE", self.url + "/api/teams/{}/members/{}".format(team_id, user_id),
 166                              headers=self.headers)
 167         if project_name != "admin":
 168             # Add member to team
 169             response_team = requests.request("GET", self.url + "/api/teams/search?name={}".format(project_name),
 170                                              headers=self.headers)
 171
 172             # Search if team in Grafana corresponding to the project already exists
 173             if not json.loads(response_team.text)["teams"]:
 174                 self.create_grafana_teams(project_name)
 175                 response_team = requests.request("GET", self.url + "/api/teams/search?name={}".format(project_name),
 176                                                  headers=self.headers)
 177             team_id = json.loads(response_team.text)["teams"][0]["id"]
 178             if project_name not in team_list:
 179                 # Create a team in Grafana corresponding to the project as it doesn't exist
 180                 member_payload = {
 181                     "userId": user_id
 182                 }
 183                 requests.request("POST", self.url + "/api/teams/{}/members".format(team_id), json=member_payload,
 184                                  headers=self.headers)
 185         # Check if user role or project name is admin
 186         if is_admin or project_name == 'admin':
 187             # Give admin righsts to user
 188             url = "/api/org/users/{}/".format(user_id)
 189             permission_payload = {"role": "Admin", }
 190             requests.request("PATCH", self.url + url, json=permission_payload, headers=self.headers)
 191             log.info("User %s is assigned Admin permission", user_name)
 192         else:
 193             # Give editor rights to user
 194             url = "/api/org/users/{}/".format(user_id)
 195             permission_payload = {"role": "Editor", }
 196             requests.request("PATCH", self.url + url, json=permission_payload, headers=self.headers)
 197             log.info("User %s is assigned Editor permission", user_name)
 198
 199     # Create team in Grafana
 200     def create_grafana_teams(self, team_name):
 201         team_payload = {"name": team_name, }
 202         requests.request("POST", self.url + "/api/teams", json=team_payload, headers=self.headers)
 203         log.info("New team %s created in Grafana", team_name)
 204
 205     # Create folder in Grafana
 206     def create_grafana_folders(self, folder_name):
 207         folder_payload = {"uid": folder_name, "title": folder_name}
 208         requests.request("POST", self.url + "/api/folders", json=folder_payload, headers=self.headers)
 209         log.info("Dashboard folder %s created", folder_name)
 210
 211         response_team = requests.request("GET", self.url + "/api/teams/search?name={}".format(folder_name),
 212                                          headers=self.headers)
 213         # Create team if it doesn't already exists
 214         if len(json.loads(response_team.text)["teams"]) == 0:
 215             self.create_grafana_teams(folder_name)
 216             response_team = requests.request("GET", self.url + "/api/teams/search?name={}".format(folder_name),
 217                                              headers=self.headers)
 218         # Assign required permission to the team's folder
 219         team_id = json.loads(response_team.text)["teams"][0]["id"]
 220         permission_data = {"items": [{"teamId": team_id, "permission": 2}, ]}
 221         requests.request("POST", self.url + "/api/folders/{}/permissions".format(folder_name),
 222                          json=permission_data, headers=self.headers)
 223
 224     # delete user from grafana
 225     def delete_grafana_users(self, user_name):
 226         # Get user id
 227         response_id = requests.request("GET", self.url + "/api/users/lookup?loginOrEmail={}".format(user_name),
 228                                        headers=self.headers)
 229         try:
 230             user_id = json.loads(response_id.text)["id"]
 231         except Exception:
 232             log.exception("Exception processing message: ")
 233         # Delete user
 234         response = requests.request("DELETE", self.url + "/api/admin/users/{}".format(user_id), headers=self.headers)
 235         log.info("User %s deleted in Grafana", user_name)
 236         return response
 237
 238     # delete team from grafana
 239     def delete_grafana_team(self, project_name):
 240         # Delete Grafana folder
 241         requests.request("DELETE", self.url + "/api/folders/{}".format(project_name),
 242                          headers=self.headers)
 243         # Delete Grafana team
 244         team_obj = requests.request("GET", self.url + "/api/teams/search?name={}".format(project_name),
 245                                     headers=self.headers)
 246         team_id = json.loads(team_obj.text)["teams"][0]["id"]
 247         response = requests.request("DELETE", self.url + "/api/teams/{}".format(team_id), headers=self.headers)
 248         log.info("Team %s deleted in Grafana", project_name)
 249         return response
 250
 251     # update grafana team
 252     def update_grafana_teams(self, project_new_name, project_old_name):
 253         team_obj = requests.request("GET", self.url + "/api/teams/search?name={}".format(project_old_name),
 254                                     headers=self.headers)
 255         team_id = json.loads(team_obj.text)["teams"][0]["id"]
 256         data = {"name": project_new_name, }
 257         response = requests.request("PUT", self.url + "/api/teams/{}".format(team_id), json=data, headers=self.headers)
 258         log.info("Grafana team updated %s", response.text)
 259         return response
 260
 261     # remove member from grafana team
 262     def remove_grafana_team_member(self, user_name, project_data):
 263         # Get user id
 264         response_id = requests.request("GET", self.url + "/api/users/lookup?loginOrEmail={}".format(user_name),
 265                                        headers=self.headers)
 266         user_id = json.loads(response_id.text)["id"]
 267         for project in project_data:
 268             # Get team id
 269             team_obj = requests.request("GET", self.url + "/api/teams/search?name={}".format(project['project']),
 270                                         headers=self.headers)
 271             team_id = json.loads(team_obj.text)["teams"][0]["id"]
 272             response = requests.request("DELETE", self.url + "/api/teams/{}/members/{}".format(team_id, user_id),
 273                                         headers=self.headers)
 274         return response