code.vuplus.com Git - vuplus_dvbapp-plugin/blob - webinterface/src/webif.py

   1 # -*- coding: UTF-8 -*-
   2 Version = '$Header$';
   3
   4 # things to improve:
   5 #       - better error handling
   6 #       - use namespace parser
   7
   8 from Tools.Import import my_import
   9
  10 from Components.Sources.Source import ObsoleteSource
  11 from Components.Converter.Converter import Converter
  12 from Components.Element import Element
  13
  14 from xml.sax import make_parser
  15 from xml.sax.handler import ContentHandler, feature_namespaces
  16 from xml.sax.saxutils import escape as escape_xml
  17 from twisted.python import util
  18 from urllib2 import quote
  19
  20 #DO NOT REMOVE THIS IMPORT
  21 #It IS used (dynamically)
  22 from WebScreens import *
  23 #DO NOT REMOVE THIS IMPORT
  24
  25
  26 # The classes and Function in File handle all ScreenPage-based requests
  27 # ScreenPages use enigma2 standard functionality to bring contents to a webfrontend
  28 #
  29 # Like Skins a ScreenPage can consist of several Elements and Converters
  30
  31 #===============================================================================
  32 # OneTimeElement
  33 #
  34 # This is the Standard Element for Rendering a "standard" WebElement
  35 #===============================================================================
  36 class OneTimeElement(Element):
  37         def __init__(self, id):
  38                 Element.__init__(self)
  39                 self.source_id = id
  40
  41         def handleCommand(self, args):
  42                 if ',' in self.source_id:
  43                         paramlist = self.source_id.split(",")
  44                         list = {}
  45                         for key in paramlist:
  46                                 arg = args.get(key, ())
  47                                 Len = len(arg)
  48                                 if Len == 0:
  49                                         list[key] = None
  50                                 elif Len == 1:
  51                                         list[key] = "".join(arg)
  52                                 elif Len == 2:
  53                                         list[key] = arg[0]
  54                         self.source.handleCommand(list)
  55                 else:
  56                         for c in args.get(self.source_id, ()):
  57                                 self.source.handleCommand(c)
  58
  59         def render(self, request):
  60                 t = self.source.getHTML(self.source_id)
  61                 request.write(t)
  62
  63         def execBegin(self):
  64                 self.suspended = False
  65
  66         def execEnd(self):
  67                 self.suspended = True
  68
  69         def onShow(self):
  70                 pass
  71
  72         def onHide(self):
  73                 pass
  74
  75         def destroy(self):
  76                 pass
  77
  78 #===============================================================================
  79 # MacroElement
  80 #
  81 # A MacroElement helps using OneTimeElements inside a (Simple)ListFiller Loop
  82 #===============================================================================
  83 class MacroElement(OneTimeElement):
  84         def __init__(self, id, macro_dict, macro_name):
  85                 OneTimeElement.__init__(self, id)
  86                 self.macro_dict = macro_dict
  87                 self.macro_name = macro_name
  88
  89         def render(self, request):
  90                 self.macro_dict[self.macro_name] = self.source.getHTML(self.source_id)
  91
  92 #===============================================================================
  93 # StreamingElement
  94 #
  95 # In difference to an OneTimeElement a StreamingElement sends an ongoing Stream
  96 # of Data. The end of the Streaming is usually when the client disconnects
  97 #===============================================================================
  98 class StreamingElement(OneTimeElement):
  99         def __init__(self, id):
 100                 OneTimeElement.__init__(self, id)
 101                 self.request = None
 102
 103         def changed(self, what):
 104                 if self.request:
 105                         self.render(self.request)
 106
 107         def setRequest(self, request):
 108                 self.request = request
 109
 110 #===============================================================================
 111 # ListItem
 112 #
 113 # a to-be-filled list item
 114 #===============================================================================
 115 class ListItem:
 116         def __init__(self, name, filternum):
 117                 self.name = name
 118                 self.filternum = filternum
 119
 120 #===============================================================================
 121 # ListMacroItem
 122 #
 123 # MacroItem inside a (Simple)ListFiller
 124 #===============================================================================
 125 class ListMacroItem:
 126         def __init__(self, macrodict, macroname):
 127                 self.macrodict = macrodict
 128                 self.macroname = macroname
 129
 130
 131 #===============================================================================
 132 # TextToHTML
 133 #
 134 # Returns the String as is
 135 #===============================================================================
 136 class TextToHTML(Converter):
 137         def __init__(self, arg):
 138                 Converter.__init__(self, arg)
 139
 140         def getHTML(self, id):
 141                 return self.source.text # encode & etc. here!
 142
 143 #===============================================================================
 144 # TextToXML
 145 #
 146 # Escapes the given Text to be XML conform
 147 #===============================================================================
 148 class TextToXML(Converter):
 149         def __init__(self, arg):
 150                 Converter.__init__(self, arg)
 151
 152         def getHTML(self, id):
 153                 return escape_xml(self.source.text).replace("\x19", "").replace("\x1c", "").replace("\x1e", "")
 154
 155 #===============================================================================
 156 # TextToURL
 157 #
 158 # Escapes the given Text so it can be used inside a URL
 159 #===============================================================================
 160 class TextToURL(Converter):
 161         def __init__(self, arg):
 162                 Converter.__init__(self, arg)
 163
 164         def getHTML(self, id):
 165                 return self.source.text.replace(" ", "%20").replace("+", "%2b").replace("&", "%26")
 166
 167 #===============================================================================
 168 # ReturnEmptyXML
 169 #
 170 # Returns a XML only consisting of <rootElement />
 171 #===============================================================================
 172 class ReturnEmptyXML(Converter):
 173         def __init__(self, arg):
 174                 Converter.__init__(self, arg)
 175
 176         def getHTML(self, id):
 177                 return "<rootElement />"
 178
 179 #===============================================================================
 180 # Null
 181 # Return simply NOTHING
 182 # Useful if you only want to issue a command.
 183 #===============================================================================
 184 class Null(Converter):
 185         def __init__(self, arg):
 186                 Converter.__init__(self, arg)
 187
 188         def getHTML(self, id):
 189                 return ""
 190
 191
 192 #===============================================================================
 193 # JavascriptUpdate
 194 #
 195 # Transforms a string into a javascript update pattern
 196 #===============================================================================
 197 class JavascriptUpdate(Converter):
 198         def __init__(self, arg):
 199                 Converter.__init__(self, arg)
 200
 201         def getHTML(self, id):
 202                 # 3c5x9, added parent. , this is because the ie loads this in a iframe. an the set is in index.html.xml
 203                 #                all other will replace this in JS
 204                 return '<script>parent.set("%s", "%s");</script>\n' % (id, self.source.text.replace("\\", "\\\\").replace("\n", "\\n").replace('"', '\\"').replace('\xb0', '&deg;'))
 205
 206 #===============================================================================
 207 # SimpleListFiller
 208 #
 209 # The performant 'one-dimensonial listfiller' engine (podlfe)
 210 #===============================================================================
 211 class SimpleListFiller(Converter):
 212         def __init__(self, arg):
 213                 Converter.__init__(self, arg)
 214
 215         def getText(self):
 216                 l = self.source.simplelist
 217                 conv_args = self.converter_arguments
 218
 219                 list = [ ]
 220                 for element in conv_args:
 221                         if isinstance(element, basestring):
 222                                 list.append((element, None))
 223                         elif isinstance(element, ListItem):
 224                                 list.append((element, element.filternum))
 225                         elif isinstance(element, ListMacroItem):
 226                                 list.append(element.macrodict[element.macroname], None)
 227                         else:
 228                                 raise Exception("neither string, ListItem nor ListMacroItem")
 229
 230                 strlist = [ ]
 231                 append = strlist.append
 232                 for item in l:
 233                         if item is None:
 234                                 item = ""
 235
 236                         for (element, filternum) in list:
 237                                 if not filternum:
 238                                         append(element)
 239                                 elif filternum == 2:
 240                                         append(str(item).replace("\\", "\\\\").replace("\n", "\\n").replace('"', '\\"'))
 241                                 elif filternum == 3:
 242                                         append(escape_xml(str(item)))
 243                                 elif filternum == 4:
 244                                         append(str(item).replace("%", "%25").replace("+", "%2B").replace('&', '%26').replace('?', '%3f').replace(' ', '+'))
 245                                 elif filternum == 5:
 246                                         append(quote(str(item)))
 247                                 elif filternum == 6:
 248                                         time = parseint(item) or 0
 249                                         t = localtime(time)
 250                                         append("%02d:%02d" % (t.tm_hour, t.tm_min))
 251                                 elif filternum == 7:
 252                                         time = parseint(item) or 0
 253                                         t = localtime(time)
 254                                         append("%d min" % (time / 60))
 255                                 else:
 256                                         append(str(item))
 257                 # (this will be done in c++ later!)
 258
 259                 return ''.join(strlist)
 260
 261         text = property(getText)
 262
 263 #===============================================================================
 264 # the performant 'listfiller'-engine (plfe)
 265 #===============================================================================
 266 class ListFiller(Converter):
 267         def __init__(self, arg):
 268                 Converter.__init__(self, arg)
 269 #               print "ListFiller-arg: ",arg
 270
 271         def getText(self):
 272                 l = self.source.list
 273                 lut = self.source.lut
 274                 conv_args = self.converter_arguments
 275
 276                 # now build a ["string", 1, "string", 2]-styled list, with indices into the
 277                 # list to avoid lookup of item name for each entry
 278                 lutlist = [ ]
 279                 for element in conv_args:
 280                         if isinstance(element, basestring):
 281                                 lutlist.append((element, None))
 282                         elif isinstance(element, ListItem):
 283                                 lutlist.append((lut[element.name], element.filternum))
 284                         elif isinstance(element, ListMacroItem):
 285                                 lutlist.append((element.macrodict[element.macroname], None))
 286                         else:
 287                                 raise Exception("neither string, ListItem nor ListMacroItem")
 288
 289                 # now, for the huge list, do:
 290                 strlist = [ ]
 291                 append = strlist.append
 292                 for item in l:
 293                         for (element, filternum) in lutlist:
 294                                 #None becomes ""
 295                                 curitem = ""
 296                                 if filternum:
 297                                         curitem = item[element]
 298                                         if curitem is None:
 299                                                 curitem = ""
 300                                 else:
 301                                         if element is None:
 302                                                 element = ""
 303
 304                                 if not filternum:
 305                                         append(element)
 306                                 elif filternum == 2:
 307                                         append(str(curitem).replace("\\", "\\\\").replace("\n", "\\n").replace('"', '\\"'))
 308                                 elif filternum == 3:
 309                                         append(escape_xml(str(curitem)))
 310                                 elif filternum == 4:
 311                                         append(str(curitem).replace("%", "%25").replace("+", "%2B").replace('&', '%26').replace('?', '%3f').replace(' ', '+'))
 312                                 elif filternum == 5:
 313                                         append(quote(str(curitem)))
 314                                 elif filternum == 6:
 315                                         from time import localtime
 316                                         time = int(float(curitem)) or 0
 317                                         t = localtime(time)
 318                                         append("%02d:%02d" % (t.tm_hour, t.tm_min))
 319                                 elif filternum == 7:
 320                                         from time import localtime
 321                                         time = int(float(curitem)) or 0
 322                                         t = localtime(time)
 323                                         append("%d min" % (time / 60))
 324                                 else:
 325                                         append(str(curitem))
 326                 # (this will be done in c++ later!)
 327
 328                 return ''.join(strlist)
 329
 330         text = property(getText)
 331
 332 #===============================================================================
 333 # webifHandler
 334 #
 335 # Handles the Content of a Web-Request
 336 # It looks up the source, instantiates the Element and Calls the Converter
 337 #===============================================================================
 338 class webifHandler(ContentHandler):
 339         def __init__(self, session, request):
 340                 self.res = [ ]
 341                 self.mode = 0
 342                 self.screen = None
 343                 self.session = session
 344                 self.screens = [ ]
 345                 self.request = request
 346                 self.macros = { }
 347
 348         def start_element(self, attrs):
 349                 scr = self.screen
 350
 351                 wsource = attrs["source"]
 352
 353                 path = wsource.split('.')
 354                 while len(path) > 1:
 355                         scr = self.screen.getRelatedScreen(path[0])
 356                         if scr is None:
 357                                 print "[webif.py] Parent Screen not found!"
 358                                 print wsource
 359                         path = path[1:]
 360
 361                 source = scr.get(path[0])
 362
 363                 if isinstance(source, ObsoleteSource):
 364                         # however, if we found an "obsolete source", issue warning, and resolve the real source.
 365                         print "WARNING: WEBIF '%s' USES OBSOLETE SOURCE '%s', USE '%s' INSTEAD!" % (name, wsource, source.new_source)
 366                         print "OBSOLETE SOURCE WILL BE REMOVED %s, PLEASE UPDATE!" % (source.removal_date)
 367                         if source.description:
 368                                 print source.description
 369
 370                         wsource = source.new_source
 371                 else:
 372                         pass
 373                         # otherwise, use that source.
 374
 375                 self.source = source
 376                 self.source_id = str(attrs.get("id", wsource))
 377                 self.is_streaming = "streaming" in attrs
 378                 self.macro_name = attrs.get("macro") or None
 379
 380         def end_element(self):
 381                 # instatiate either a StreamingElement or a OneTimeElement, depending on what's required.
 382                 if not self.is_streaming:
 383                         if self.macro_name is None:
 384                                 c = OneTimeElement(self.source_id)
 385                         else:
 386                                 c = MacroElement(self.source_id, self.macros, self.macro_name)
 387                 else:
 388                         assert self.macro_name is None
 389                         c = StreamingElement(self.source_id)
 390
 391                 c.connect(self.source)
 392                 self.res.append(c)
 393                 self.screen.renderer.append(c)
 394                 del self.source
 395
 396         def start_convert(self, attrs):
 397                 ctype = attrs["type"]
 398
 399                 # TODO: we need something better here
 400                 if ctype[:4] == "web:": # for now
 401                         self.converter = eval(ctype[4:])
 402                 else:
 403                         try:
 404                                 self.converter = my_import('.'.join(("Components", "Converter", ctype))).__dict__.get(ctype)
 405                         except ImportError:
 406                                 self.converter = my_import('.'.join(("Plugins", "Extensions", "WebInterface", "WebComponents", "Converter", ctype))).__dict__.get(ctype)
 407                 self.sub = [ ]
 408
 409         def end_convert(self):
 410                 if len(self.sub) == 1:
 411                         self.sub = self.sub[0]
 412                 c = self.converter(self.sub)
 413                 c.connect(self.source)
 414                 self.source = c
 415                 del self.sub
 416
 417         def parse_item(self, attrs):
 418                 if "name" in attrs:
 419                         filter = {"": 1, "javascript_escape": 2, "xml": 3, "uri": 4, "urlencode": 5, "time": 6, "minutes": 7}[attrs.get("filter", "")]
 420                         self.sub.append(ListItem(attrs["name"], filter))
 421                 else:
 422                         assert "macro" in attrs, "e2:item must have a name= or macro= attribute!"
 423                         self.sub.append(ListMacroItem(self.macros, attrs["macro"]))
 424
 425         def startElement(self, name, attrs):
 426                 if name == "e2:screen":
 427                         self.screen = eval(attrs["name"])(self.session, self.request) # fixme
 428                         self.screens.append(self.screen)
 429                         return
 430
 431                 if name[:3] == "e2:":
 432                         self.mode += 1
 433
 434                 tag = '<' + name + ''.join([' %s="%s"' % x for x in attrs.items()]) + '>'
 435                 #tag = tag.encode('utf-8')
 436
 437                 if self.mode == 0:
 438                         self.res.append(tag)
 439                 elif self.mode == 1: # expect "<e2:element>"
 440                         assert name == "e2:element", "found %s instead of e2:element" % name
 441                         self.start_element(attrs)
 442                 elif self.mode == 2: # expect "<e2:convert>"
 443                         if name[:3] == "e2:":
 444                                 assert name == "e2:convert"
 445                                 self.start_convert(attrs)
 446                         else:
 447                                 self.sub.append(tag)
 448                 elif self.mode == 3:
 449                         assert name == "e2:item", "found %s instead of e2:item!" % name
 450
 451                         self.parse_item(attrs)
 452
 453         def endElement(self, name):
 454                 if name == "e2:screen":
 455                         self.screen = None
 456                         return
 457
 458                 tag = "</" + name + ">"
 459                 if self.mode == 0:
 460                         self.res.append(tag)
 461                 elif self.mode == 2 and name[:3] != "e2:":
 462                         self.sub.append(tag)
 463                 elif self.mode == 2: # closed 'convert' -> sub
 464                         self.end_convert()
 465                 elif self.mode == 1: # closed 'element'
 466                         self.end_element()
 467                 if name[:3] == "e2:":
 468                         self.mode -= 1
 469
 470         def processingInstruction(self, target, data):
 471                 self.res.append('<?' + target + ' ' + data + '>')
 472
 473         def characters(self, ch):
 474                 ch = ch.encode('utf-8')
 475                 if self.mode == 0:
 476                         self.res.append(ch)
 477                 elif self.mode == 2:
 478                         self.sub.append(ch)
 479
 480         def startEntity(self, name):
 481                 self.res.append('&' + name + ';');
 482
 483         def execBegin(self):
 484                 for screen in self.screens:
 485                         screen.execBegin()
 486
 487         def cleanup(self):
 488                 print "screen cleanup!"
 489                 for screen in self.screens:
 490                         screen.execEnd()
 491                         screen.doClose()
 492                 self.screens = [ ]
 493
 494 #===============================================================================
 495 # renderPage
 496 #
 497 # Creates the Handler for a Request and calls it
 498 # Also ensures that the Handler is finished after the Request is done
 499 #===============================================================================
 500 def renderPage(request, path, session):
 501         # read in the template, create required screens
 502         # we don't have persistense yet.
 503         # if we had, this first part would only be done once.
 504         handler = webifHandler(session, request)
 505         parser = make_parser()
 506         parser.setFeature(feature_namespaces, 0)
 507         parser.setContentHandler(handler)
 508         parser.parse(open(util.sibpath(__file__, path)))
 509
 510         # by default, we have non-streaming pages
 511         finish = True
 512
 513         # first, apply "commands" (aka. URL argument)
 514         for x in handler.res:
 515                 if isinstance(x, Element):
 516                         x.handleCommand(request.args)
 517
 518         handler.execBegin()
 519
 520         # now, we have a list with static texts mixed
 521         # with non-static Elements.
 522         # flatten this list, write into the request.
 523         for x in handler.res:
 524                 if isinstance(x, Element):
 525                         if isinstance(x, StreamingElement):
 526                                 finish = False
 527                                 x.setRequest(request)
 528                         x.render(request)
 529                 else:
 530                         request.write(str(x))
 531
 532         # if we met a "StreamingElement", there is at least one
 533         # element which wants to output data more than once,
 534         # i.e. on host-originated changes.
 535         # in this case, don't finish yet, don't cleanup yet,
 536         # but instead do that when the client disconnects.
 537         if finish:
 538                 requestFinish(handler, request)
 539
 540         else:
 541                 def requestFinishDeferred(nothing, handler, request):
 542                         from twisted.internet import reactor
 543                         reactor.callLater(0, requestFinish, handler, request)
 544
 545                 d = request.notifyFinish()
 546
 547                 d.addBoth( requestFinishDeferred, handler, request )
 548
 549 #===============================================================================
 550 # requestFinish
 551 #
 552 # This has to be/is called at the end of every ScreenPage-based Request
 553 #===============================================================================
 554 def requestFinish(handler, request):
 555         handler.cleanup()
 556         request.finish()
 557
 558         del handler