ipsilon/admin/common.py

   1 # Copyright (C) 2014  Simo Sorce <simo@redhat.com>
   2 #
   3 # see file 'COPYING' for use and warranty information
   4 #
   5 # This program is free software; you can redistribute it and/or modify
   6 # it under the terms of the GNU General Public License as published by
   7 # the Free Software Foundation, either version 3 of the License, or
   8 # (at your option) any later version.
   9 #
  10 # This program is distributed in the hope that it will be useful,
  11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 # GNU General Public License for more details.
  14 #
  15 # You should have received a copy of the GNU General Public License
  16 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18 import cherrypy
  19 from ipsilon.util.page import Page
  20 from ipsilon.util.page import admin_protect
  21 from ipsilon.util.endpoint import allow_iframe
  22 from ipsilon.util import config as pconfig
  23
  24
  25 ADMIN_STATUS_OK = "success"
  26 ADMIN_STATUS_ERROR = "danger"
  27 ADMIN_STATUS_WARN = "warning"
  28
  29
  30 class AdminError(Exception):
  31     def __init__(self, message):
  32         super(AdminError, self).__init__(message)
  33         self.message = message
  34
  35     def __str__(self):
  36         return str(self.message)
  37
  38
  39 class AdminPage(Page):
  40
  41     def __init__(self, *args, **kwargs):
  42         super(AdminPage, self).__init__(*args, **kwargs)
  43         self.auth_protect = True
  44
  45
  46 class AdminPluginConfig(AdminPage):
  47
  48     def __init__(self, po, site, parent):
  49         super(AdminPluginConfig, self).__init__(site, form=True)
  50         self._po = po
  51         self.title = '%s plugin' % po.name
  52         self.url = '%s/%s' % (parent.url, po.name)
  53         self.facility = parent.facility
  54         self.menu = [parent]
  55         self.back = parent.url
  56
  57     def root_with_msg(self, message=None, message_type=None):
  58         return self._template('admin/option_config.html', title=self.title,
  59                               menu=self.menu, action=self.url, back=self.back,
  60                               message=message, message_type=message_type,
  61                               name='admin_%s_%s_form' % (self.facility,
  62                                                          self._po.name),
  63                               config=self._po.get_config_obj())
  64
  65     @admin_protect
  66     def GET(self, *args, **kwargs):
  67         return self.root_with_msg()
  68
  69     @admin_protect
  70     def POST(self, *args, **kwargs):
  71
  72         if self._po.is_readonly:
  73             return self.root_with_msg(
  74                 message="Configuration is marked Read-Only",
  75                 message_type=ADMIN_STATUS_WARN)
  76
  77         message = "Nothing was modified."
  78         message_type = "info"
  79         new_db_values = dict()
  80
  81         conf = self._po.get_config_obj()
  82
  83         for name, option in conf.iteritems():
  84             if name in kwargs:
  85                 value = kwargs[name]
  86                 if isinstance(option, pconfig.List):
  87                     value = [x.strip() for x in value.split('\n')]
  88                 elif isinstance(option, pconfig.Condition):
  89                     value = True
  90             else:
  91                 if isinstance(option, pconfig.Condition):
  92                     value = False
  93                 elif isinstance(option, pconfig.Choice):
  94                     value = list()
  95                     for a in option.get_allowed():
  96                         aname = '%s_%s' % (name, a)
  97                         if aname in kwargs:
  98                             value.append(a)
  99                 elif type(option) is pconfig.ComplexList:
 100                     value = get_complex_list_value(name,
 101                                                    option.get_value(),
 102                                                    **kwargs)
 103                     if value is None:
 104                         continue
 105                 elif type(option) is pconfig.MappingList:
 106                     value = get_mapping_list_value(name,
 107                                                    option.get_value(),
 108                                                    **kwargs)
 109                     if value is None:
 110                         continue
 111                 else:
 112                     continue
 113
 114             if value != option.get_value():
 115                 cherrypy.log.error("Storing [%s]: %s = %s" %
 116                                    (self._po.name, name, value))
 117             option.set_value(value)
 118             new_db_values[name] = option.export_value()
 119
 120         if len(new_db_values) != 0:
 121             # First we try to save in the database
 122             try:
 123                 self._po.save_plugin_config(new_db_values)
 124                 message = "New configuration saved."
 125                 message_type = ADMIN_STATUS_OK
 126             except Exception as e:  # pylint: disable=broad-except
 127                 self.error('Failed to save data: %s' % e)
 128                 message = "Failed to save data!"
 129                 message_type = ADMIN_STATUS_ERROR
 130
 131             # Then refresh the actual objects
 132             self._po.refresh_plugin_config()
 133
 134         return self.root_with_msg(message=message,
 135                                   message_type=message_type)
 136
 137
 138 class AdminPluginsOrder(AdminPage):
 139
 140     def __init__(self, site, parent, facility):
 141         super(AdminPluginsOrder, self).__init__(site, form=True)
 142         self.parent = parent
 143         self.facility = facility
 144         self.url = '%s/order' % parent.url
 145         self.menu = [parent]
 146
 147     @admin_protect
 148     def GET(self, *args, **kwargs):
 149         return self.parent.root_with_msg()
 150
 151     @admin_protect
 152     def POST(self, *args, **kwargs):
 153
 154         if self._site[self.facility].is_readonly:
 155             return self.parent.root_with_msg(
 156                 message="Configuration is marked Read-Only",
 157                 message_type=ADMIN_STATUS_WARN)
 158
 159         message = "Nothing was modified."
 160         message_type = "info"
 161         changed = None
 162         cur_enabled = self._site[self.facility].enabled
 163
 164         if 'order' in kwargs:
 165             order = kwargs['order'].split(',')
 166             if len(order) != 0:
 167                 new_order = []
 168                 try:
 169                     for v in order:
 170                         val = v.strip()
 171                         if val not in cur_enabled:
 172                             error = "Invalid plugin name: %s" % val
 173                             raise ValueError(error)
 174                         new_order.append(val)
 175                     if len(new_order) < len(cur_enabled):
 176                         for val in cur_enabled:
 177                             if val not in new_order:
 178                                 new_order.append(val)
 179
 180                     self.parent.save_enabled_plugins(new_order)
 181
 182                     # When all is saved update also live config. The
 183                     # live config is the ordered list of plugin names.
 184                     self._site[self.facility].refresh_enabled()
 185
 186                     message = "New configuration saved."
 187                     message_type = ADMIN_STATUS_OK
 188
 189                     changed = dict()
 190                     self.debug('%s -> %s' % (cur_enabled, new_order))
 191                     for i in range(0, len(cur_enabled)):
 192                         if cur_enabled[i] != new_order[i]:
 193                             changed[cur_enabled[i]] = 'reordered'
 194
 195                 except ValueError, e:
 196                     message = str(e)
 197                     message_type = ADMIN_STATUS_ERROR
 198
 199                 except Exception as e:  # pylint: disable=broad-except
 200                     self.error('Failed to save data: %s' % e)
 201                     message = "Failed to save data!"
 202                     message_type = ADMIN_STATUS_ERROR
 203
 204         return self.parent.root_with_msg(message=message,
 205                                          message_type=message_type,
 206                                          changed=changed)
 207
 208
 209 class AdminPlugins(AdminPage):
 210     def __init__(self, name, site, parent, facility, ordered=True):
 211         super(AdminPlugins, self).__init__(site)
 212         self._master = parent
 213         self.name = name
 214         self.title = '%s plugins' % name
 215         self.url = '%s/%s' % (parent.url, name)
 216         self.facility = facility
 217         self.template = 'admin/plugins.html'
 218         self.order = None
 219         parent.add_subtree(name, self)
 220
 221         for plugin in self._site[facility].available:
 222             cherrypy.log.error('Admin info plugin: %s' % plugin)
 223             obj = self._site[facility].available[plugin]
 224             page = AdminPluginConfig(obj, self._site, self)
 225             if hasattr(obj, 'admin'):
 226                 obj.admin.mount(page)
 227             self.add_subtree(plugin, page)
 228
 229         if ordered:
 230             self.order = AdminPluginsOrder(self._site, self, facility)
 231
 232     def save_enabled_plugins(self, names):
 233         self._site[self.facility].save_enabled(names)
 234
 235     def root_with_msg(self, message=None, message_type=None, changed=None):
 236         plugins = self._site[self.facility]
 237
 238         if changed is None:
 239             changed = dict()
 240
 241         targs = {'title': self.title,
 242                  'menu': self._master.menu,
 243                  'message': message,
 244                  'message_type': message_type,
 245                  'available': plugins.available,
 246                  'enabled': plugins.enabled,
 247                  'changed': changed,
 248                  'baseurl': self.url,
 249                  'newurl': self.url}
 250         if self.order:
 251             targs['order_name'] = '%s_order_form' % self.name
 252             targs['order_action'] = self.order.url
 253
 254         # pylint: disable=star-args
 255         return self._template(self.template, **targs)
 256
 257     def root(self, *args, **kwargs):
 258         return self.root_with_msg()
 259
 260     def _get_plugin_obj(self, plugin):
 261         plugins = self._site[self.facility]
 262         if plugins.is_readonly:
 263             msg = "Configuration is marked Read-Only"
 264             raise AdminError(msg)
 265         if plugin not in plugins.available:
 266             msg = "Unknown plugin %s" % plugin
 267             raise AdminError(msg)
 268         obj = plugins.available[plugin]
 269         if obj.is_readonly:
 270             msg = "Plugin Configuration is marked Read-Only"
 271             raise AdminError(msg)
 272         return obj
 273
 274     @admin_protect
 275     def enable(self, plugin):
 276         msg = None
 277         try:
 278             obj = self._get_plugin_obj(plugin)
 279         except AdminError, e:
 280             return self.root_with_msg(str(e), ADMIN_STATUS_WARN)
 281         if not obj.is_enabled:
 282             obj.enable()
 283             obj.save_enabled_state()
 284             msg = "Plugin %s enabled" % obj.name
 285         return self.root_with_msg(msg, ADMIN_STATUS_OK,
 286                                   changed={obj.name: 'enabled'})
 287     enable.public_function = True
 288
 289     @admin_protect
 290     def disable(self, plugin):
 291         msg = None
 292         try:
 293             obj = self._get_plugin_obj(plugin)
 294         except AdminError, e:
 295             return self.root_with_msg(str(e), ADMIN_STATUS_WARN)
 296         if obj.is_enabled:
 297             obj.disable()
 298             obj.save_enabled_state()
 299             msg = "Plugin %s disabled" % obj.name
 300         return self.root_with_msg(msg, ADMIN_STATUS_OK,
 301                                   changed={obj.name: 'disabled'})
 302     disable.public_function = True
 303
 304
 305 class Admin(AdminPage):
 306
 307     def __init__(self, site, mount):
 308         super(Admin, self).__init__(site)
 309         self.title = 'Home'
 310         self.mount = mount
 311         self.url = '%s/%s' % (self.basepath, mount)
 312         self.menu = [self]
 313
 314     def root(self, *args, **kwargs):
 315         return self._template('admin/index.html',
 316                               title='Configuration',
 317                               baseurl=self.url,
 318                               menu=self.menu)
 319
 320     def add_subtree(self, name, page):
 321         self.__dict__[name] = page
 322         self.menu.append(page)
 323
 324     def del_subtree(self, name):
 325         self.menu.remove(self.__dict__[name])
 326         del self.__dict__[name]
 327
 328     def get_menu_urls(self):
 329         urls = dict()
 330         for item in self.menu:
 331             name = getattr(item, 'name', None)
 332             if name:
 333                 urls['%s_url' % name] = cherrypy.url('/%s/%s' % (self.mount,
 334                                                                  name))
 335         return urls
 336
 337     @admin_protect
 338     @allow_iframe
 339     def scheme(self):
 340         cherrypy.response.headers.update({'Content-Type': 'image/svg+xml'})
 341         urls = self.get_menu_urls()
 342         # pylint: disable=star-args
 343         return str(self._template('admin/ipsilon-scheme.svg', **urls))
 344     scheme.public_function = True
 345
 346
 347 def get_complex_list_value(name, old_value, **kwargs):
 348     delete = list()
 349     change = dict()
 350     for key, val in kwargs.iteritems():
 351         if not key.startswith(name):
 352             continue
 353         n = key[len(name):]
 354         if len(n) == 0 or n[0] != ' ':
 355             continue
 356         try:
 357             index, field = n[1:].split('-')
 358         except ValueError:
 359             continue
 360         if field == 'delete':
 361             delete.append(int(index))
 362         elif field == 'name':
 363             change[int(index)] = val
 364
 365     if len(delete) == 0 and len(change) == 0:
 366         return None
 367
 368     value = old_value
 369
 370     # remove unwanted changes
 371     for i in delete:
 372         if i in change:
 373             del change[i]
 374
 375     # perform requested changes
 376     for index, val in change.iteritems():
 377         val_list = val.split('/')
 378         stripped = list()
 379         for v in val_list:
 380             stripped.append(v.strip())
 381         if len(stripped) == 1:
 382             stripped = stripped[0]
 383         if len(value) <= index:
 384             value.extend([None]*(index + 1 - len(value)))
 385         value[index] = stripped
 386
 387         if len(value[index]) == 0:
 388             value[index] = None
 389
 390     # the previous loop may add 'None' entries
 391     # if any still exists mark them to be deleted
 392     for i in xrange(0, len(value)):
 393         if value[i] is None:
 394             delete.append(i)
 395
 396     # remove duplicates and set in reverse order
 397     delete = list(set(delete))
 398     delete.sort(reverse=True)
 399
 400     for i in delete:
 401         if len(value) > i:
 402             del value[i]
 403
 404     if len(value) == 0:
 405         value = None
 406     return value
 407
 408
 409 def get_mapping_list_value(name, old_value, **kwargs):
 410     delete = list()
 411     change = dict()
 412     for key, val in kwargs.iteritems():
 413         if not key.startswith(name):
 414             continue
 415         n = key[len(name):]
 416         if len(n) == 0 or n[0] != ' ':
 417             continue
 418         try:
 419             index, field = n[1:].split('-')
 420         except ValueError:
 421             continue
 422         if field == 'delete':
 423             delete.append(int(index))
 424         else:
 425             i = int(index)
 426             if i not in change:
 427                 change[i] = dict()
 428             change[i][field] = val
 429
 430     if len(delete) == 0 and len(change) == 0:
 431         return None
 432
 433     value = old_value
 434
 435     # remove unwanted changes
 436     for i in delete:
 437         if i in change:
 438             del change[i]
 439
 440     # perform requested changes
 441     for index, fields in change.iteritems():
 442         for k in 'from', 'to':
 443             if k in fields:
 444                 val = fields[k]
 445                 val_list = val.split('/')
 446                 stripped = list()
 447                 for v in val_list:
 448                     stripped.append(v.strip())
 449                 if len(stripped) == 1:
 450                     stripped = stripped[0]
 451                 if len(value) <= index:
 452                     value.extend([None]*(index + 1 - len(value)))
 453                 if value[index] is None:
 454                     value[index] = [None, None]
 455                 if k == 'from':
 456                     i = 0
 457                 else:
 458                     i = 1
 459                 value[index][i] = stripped
 460
 461         # eliminate incomplete/incorrect entries
 462         if value[index] is not None:
 463             if ((len(value[index]) != 2 or
 464                  value[index][0] is None or
 465                  len(value[index][0]) == 0 or
 466                  value[index][1] is None or
 467                  len(value[index][1]) == 0)):
 468                 value[index] = None
 469
 470     # the previous loop may add 'None' entries
 471     # if any still exists mark them to be deleted
 472     for i in xrange(0, len(value)):
 473         if value[i] is None:
 474             delete.append(i)
 475
 476     # remove duplicates and set in reverse order
 477     delete = list(set(delete))
 478     delete.sort(reverse=True)
 479
 480     for i in delete:
 481         if len(value) > i:
 482             del value[i]
 483
 484     if len(value) == 0:
 485         value = None
 486     return value