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