micro-optimizations
[enigma2-plugins.git] / 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")
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 = [' %s="%s"' % (key, val) for (key, val) in attrs.items()]
435                 tag.insert(0, name)
436                 tag.insert(0, '<')
437                 tag.append('>')
438                 tag = ''.join(tag)#.encode('utf-8')
439
440                 if self.mode == 0:
441                         self.res.append(tag)
442                 elif self.mode == 1: # expect "<e2:element>"
443                         assert name == "e2:element", "found %s instead of e2:element" % name
444                         self.start_element(attrs)
445                 elif self.mode == 2: # expect "<e2:convert>"
446                         if name[:3] == "e2:":
447                                 assert name == "e2:convert"
448                                 self.start_convert(attrs)
449                         else:
450                                 self.sub.append(tag)
451                 elif self.mode == 3:
452                         assert name == "e2:item", "found %s instead of e2:item!" % name
453
454                         self.parse_item(attrs)
455
456         def endElement(self, name):
457                 if name == "e2:screen":
458                         self.screen = None
459                         return
460
461                 tag = "</" + name + ">"
462                 if self.mode == 0:
463                         self.res.append(tag)
464                 elif self.mode == 2 and name[:3] != "e2:":
465                         self.sub.append(tag)
466                 elif self.mode == 2: # closed 'convert' -> sub
467                         self.end_convert()
468                 elif self.mode == 1: # closed 'element'
469                         self.end_element()
470                 if name[:3] == "e2:":
471                         self.mode -= 1
472
473         def processingInstruction(self, target, data):
474                 self.res.append('<?' + target + ' ' + data + '>')
475
476         def characters(self, ch):
477                 ch = ch.encode('utf-8')
478                 if self.mode == 0:
479                         self.res.append(ch)
480                 elif self.mode == 2:
481                         self.sub.append(ch)
482
483         def startEntity(self, name):
484                 self.res.append('&' + name + ';');
485
486         def execBegin(self):
487                 for screen in self.screens:
488                         screen.execBegin()
489
490         def cleanup(self):
491                 print "screen cleanup!"
492                 for screen in self.screens:
493                         screen.execEnd()
494                         screen.doClose()
495                 self.screens = [ ]
496
497 #===============================================================================
498 # renderPage
499 #
500 # Creates the Handler for a Request and calls it
501 # Also ensures that the Handler is finished after the Request is done
502 #===============================================================================
503 def renderPage(request, path, session):
504         # read in the template, create required screens
505         # we don't have persistense yet.
506         # if we had, this first part would only be done once.
507         handler = webifHandler(session, request)
508         parser = make_parser()
509         parser.setFeature(feature_namespaces, 0)
510         parser.setContentHandler(handler)
511         parser.parse(open(util.sibpath(__file__, path)))
512
513         # by default, we have non-streaming pages
514         finish = True
515
516         # first, apply "commands" (aka. URL argument)
517         for x in handler.res:
518                 if isinstance(x, Element):
519                         x.handleCommand(request.args)
520
521         handler.execBegin()
522
523         # now, we have a list with static texts mixed
524         # with non-static Elements.
525         # flatten this list, write into the request.
526         for x in handler.res:
527                 if isinstance(x, Element):
528                         if isinstance(x, StreamingElement):
529                                 finish = False
530                                 x.setRequest(request)
531                         x.render(request)
532                 else:
533                         request.write(str(x))
534
535         # if we met a "StreamingElement", there is at least one
536         # element which wants to output data more than once,
537         # i.e. on host-originated changes.
538         # in this case, don't finish yet, don't cleanup yet,
539         # but instead do that when the client disconnects.
540         if finish:
541                 requestFinish(handler, request)
542         
543         else:   
544                 def requestFinishDeferred(nothing, handler, request):
545                         from twisted.internet import reactor
546                         reactor.callLater(1, requestFinish, handler, request)                           
547                 
548                 d = request.notifyFinish()
549
550                 d.addErrback( requestFinishDeferred, handler, request )
551                 d.addCallback( requestFinishDeferred, handler, request )
552                                                         
553 #===============================================================================
554 # requestFinish
555 #
556 # This has to be/is called at the end of every ScreenPage-based Request
557 #===============================================================================
558 def requestFinish(handler, request):
559         handler.cleanup()
560         request.finish()        
561         
562         del handler