']
189 | routeArgNames = []
190 | routeRegex = ''
191 | for s in routeParts :
192 | if s.startswith('<') and s.endswith('>') :
193 | routeArgNames.append(s[1:-1])
194 | routeRegex += '/(\\w*)'
195 | elif s :
196 | routeRegex += '/' + s
197 | routeRegex += '$'
198 | # -> '/users/(\w*)/addresses/(\w*)/test/(\w*)$'
199 | routeRegex = re.compile(routeRegex)
200 |
201 | self._routeHandlers.append(MicroWebSrvRoute(route, method, func, routeArgNames, routeRegex))
202 |
203 | # ============================================================================
204 | # ===( Server Process )=======================================================
205 | # ============================================================================
206 |
207 | def _serverProcess(self) :
208 | self._started = True
209 | while True :
210 | try :
211 | client, cliAddr = self._server.accept()
212 | except Exception as ex :
213 | if ex.args and ex.args[0] == 113 :
214 | break
215 | continue
216 | self._client(self, client, cliAddr)
217 | self._started = False
218 |
219 | # ============================================================================
220 | # ===( Functions )============================================================
221 | # ============================================================================
222 |
223 | def Start(self, threaded=False) :
224 | if not self._started :
225 | self._server = socket.socket()
226 | self._server.setsockopt( socket.SOL_SOCKET,
227 | socket.SO_REUSEADDR,
228 | 1 )
229 | self._server.bind(self._srvAddr)
230 | self._server.listen(16)
231 | if threaded :
232 | MicroWebSrv._startThread(self._serverProcess)
233 | else :
234 | self._serverProcess()
235 |
236 | # ----------------------------------------------------------------------------
237 |
238 | def Stop(self) :
239 | if self._started :
240 | self._server.close()
241 |
242 | # ----------------------------------------------------------------------------
243 |
244 | def IsStarted(self) :
245 | return self._started
246 |
247 | # ----------------------------------------------------------------------------
248 |
249 | def SetNotFoundPageUrl(self, url=None) :
250 | self._notFoundUrl = url
251 |
252 | # ----------------------------------------------------------------------------
253 |
254 | def GetMimeTypeFromFilename(self, filename) :
255 | filename = filename.lower()
256 | for ext in self._mimeTypes :
257 | if filename.endswith(ext) :
258 | return self._mimeTypes[ext]
259 | return None
260 |
261 | # ----------------------------------------------------------------------------
262 |
263 | def GetRouteHandler(self, resUrl, method) :
264 | if self._routeHandlers :
265 | #resUrl = resUrl.upper()
266 | if resUrl.endswith('/') :
267 | resUrl = resUrl[:-1]
268 | method = method.upper()
269 | for rh in self._routeHandlers :
270 | if rh.method == method :
271 | m = rh.routeRegex.match(resUrl)
272 | if m : # found matching route?
273 | if rh.routeArgNames :
274 | routeArgs = {}
275 | for i, name in enumerate(rh.routeArgNames) :
276 | value = m.group(i+1)
277 | try :
278 | value = int(value)
279 | except :
280 | pass
281 | routeArgs[name] = value
282 | return (rh.func, routeArgs)
283 | else :
284 | return (rh.func, None)
285 | return (None, None)
286 |
287 | # ----------------------------------------------------------------------------
288 |
289 | def _physPathFromURLPath(self, urlPath) :
290 | if urlPath == '/' :
291 | for idxPage in self._indexPages :
292 | physPath = self._webPath + '/' + idxPage
293 | if MicroWebSrv._fileExists(physPath) :
294 | return physPath
295 | else :
296 | physPath = self._webPath + urlPath.replace('../', '/')
297 | if MicroWebSrv._fileExists(physPath) :
298 | return physPath
299 | return None
300 |
301 | # ============================================================================
302 | # ===( Class Client )========================================================
303 | # ============================================================================
304 |
305 | class _client :
306 |
307 | # ------------------------------------------------------------------------
308 |
309 | def __init__(self, microWebSrv, socket, addr) :
310 | socket.settimeout(2)
311 | self._microWebSrv = microWebSrv
312 | self._socket = socket
313 | self._addr = addr
314 | self._method = None
315 | self._path = None
316 | self._httpVer = None
317 | self._resPath = "/"
318 | self._queryString = ""
319 | self._queryParams = { }
320 | self._headers = { }
321 | self._contentType = None
322 | self._contentLength = 0
323 |
324 | if hasattr(socket, 'readline'): # MicroPython
325 | self._socketfile = self._socket
326 | else: # CPython
327 | self._socketfile = self._socket.makefile('rwb')
328 |
329 | self._processRequest()
330 |
331 | # ------------------------------------------------------------------------
332 |
333 | def _processRequest(self) :
334 | try :
335 | response = MicroWebSrv._response(self)
336 | if self._parseFirstLine(response) :
337 | if self._parseHeader(response) :
338 | upg = self._getConnUpgrade()
339 | if not upg :
340 | routeHandler, routeArgs = self._microWebSrv.GetRouteHandler(self._resPath, self._method)
341 | if routeHandler :
342 | try :
343 | if routeArgs is not None:
344 | routeHandler(self, response, routeArgs)
345 | else :
346 | routeHandler(self, response)
347 | except Exception as ex :
348 | print('MicroWebSrv handler exception:\r\n - In route %s %s\r\n - %s' % (self._method, self._resPath, ex))
349 | raise ex
350 | elif self._method.upper() == "GET" :
351 | filepath = self._microWebSrv._physPathFromURLPath(self._resPath)
352 | if filepath :
353 | if MicroWebSrv._isPyHTMLFile(filepath) :
354 | response.WriteResponsePyHTMLFile(filepath)
355 | else :
356 | contentType = self._microWebSrv.GetMimeTypeFromFilename(filepath)
357 | if contentType :
358 | if self._microWebSrv.LetCacheStaticContentLevel > 0 :
359 | if self._microWebSrv.LetCacheStaticContentLevel > 1 and \
360 | 'if-modified-since' in self._headers :
361 | response.WriteResponseNotModified()
362 | else:
363 | headers = { 'Last-Modified' : 'Fri, 1 Jan 2018 23:42:00 GMT', \
364 | 'Cache-Control' : 'max-age=315360000' }
365 | response.WriteResponseFile(filepath, contentType, headers)
366 | else :
367 | response.WriteResponseFile(filepath, contentType)
368 | else :
369 | response.WriteResponseForbidden()
370 | else :
371 | response.WriteResponseNotFound()
372 | else :
373 | response.WriteResponseMethodNotAllowed()
374 | elif upg == 'websocket' and 'MicroWebSocket' in globals() \
375 | and self._microWebSrv.AcceptWebSocketCallback :
376 | MicroWebSocket( socket = self._socket,
377 | httpClient = self,
378 | httpResponse = response,
379 | maxRecvLen = self._microWebSrv.MaxWebSocketRecvLen,
380 | threaded = self._microWebSrv.WebSocketThreaded,
381 | acceptCallback = self._microWebSrv.AcceptWebSocketCallback )
382 | return
383 | else :
384 | response.WriteResponseNotImplemented()
385 | else :
386 | response.WriteResponseBadRequest()
387 | except :
388 | response.WriteResponseInternalServerError()
389 | try :
390 | if self._socketfile is not self._socket:
391 | self._socketfile.close()
392 | self._socket.close()
393 | except :
394 | pass
395 |
396 | # ------------------------------------------------------------------------
397 |
398 | def _parseFirstLine(self, response) :
399 | try :
400 | elements = self._socketfile.readline().decode().strip().split()
401 | if len(elements) == 3 :
402 | self._method = elements[0].upper()
403 | self._path = elements[1]
404 | self._httpVer = elements[2].upper()
405 | elements = self._path.split('?', 1)
406 | if len(elements) > 0 :
407 | self._resPath = MicroWebSrv._unquote_plus(elements[0])
408 | if len(elements) > 1 :
409 | self._queryString = elements[1]
410 | elements = self._queryString.split('&')
411 | for s in elements :
412 | param = s.split('=', 1)
413 | if len(param) > 0 :
414 | value = MicroWebSrv._unquote(param[1]) if len(param) > 1 else ''
415 | self._queryParams[MicroWebSrv._unquote(param[0])] = value
416 | return True
417 | except :
418 | pass
419 | return False
420 |
421 | # ------------------------------------------------------------------------
422 |
423 | def _parseHeader(self, response) :
424 | while True :
425 | elements = self._socketfile.readline().decode().strip().split(':', 1)
426 | if len(elements) == 2 :
427 | self._headers[elements[0].strip().lower()] = elements[1].strip()
428 | elif len(elements) == 1 and len(elements[0]) == 0 :
429 | if self._method == 'POST' or self._method == 'PUT' :
430 | self._contentType = self._headers.get("content-type", None)
431 | self._contentLength = int(self._headers.get("content-length", 0))
432 | return True
433 | else :
434 | return False
435 |
436 | # ------------------------------------------------------------------------
437 |
438 | def _getConnUpgrade(self) :
439 | if 'upgrade' in self._headers.get('connection', '').lower() :
440 | return self._headers.get('upgrade', '').lower()
441 | return None
442 |
443 | # ------------------------------------------------------------------------
444 |
445 | def GetServer(self) :
446 | return self._microWebSrv
447 |
448 | # ------------------------------------------------------------------------
449 |
450 | def GetAddr(self) :
451 | return self._addr
452 |
453 | # ------------------------------------------------------------------------
454 |
455 | def GetIPAddr(self) :
456 | return self._addr[0]
457 |
458 | # ------------------------------------------------------------------------
459 |
460 | def GetPort(self) :
461 | return self._addr[1]
462 |
463 | # ------------------------------------------------------------------------
464 |
465 | def GetRequestMethod(self) :
466 | return self._method
467 |
468 | # ------------------------------------------------------------------------
469 |
470 | def GetRequestTotalPath(self) :
471 | return self._path
472 |
473 | # ------------------------------------------------------------------------
474 |
475 | def GetRequestPath(self) :
476 | return self._resPath
477 |
478 | # ------------------------------------------------------------------------
479 |
480 | def GetRequestQueryString(self) :
481 | return self._queryString
482 |
483 | # ------------------------------------------------------------------------
484 |
485 | def GetRequestQueryParams(self) :
486 | return self._queryParams
487 |
488 | # ------------------------------------------------------------------------
489 |
490 | def GetRequestHeaders(self) :
491 | return self._headers
492 |
493 | # ------------------------------------------------------------------------
494 |
495 | def GetRequestContentType(self) :
496 | return self._contentType
497 |
498 | # ------------------------------------------------------------------------
499 |
500 | def GetRequestContentLength(self) :
501 | return self._contentLength
502 |
503 | # ------------------------------------------------------------------------
504 |
505 | def ReadRequestContent(self, size=None) :
506 | if size is None :
507 | size = self._contentLength
508 | if size > 0 :
509 | try :
510 | return self._socketfile.read(size)
511 | except :
512 | pass
513 | return b''
514 |
515 | # ------------------------------------------------------------------------
516 |
517 | def ReadRequestPostedFormData(self) :
518 | res = { }
519 | data = self.ReadRequestContent()
520 | if data :
521 | elements = data.decode().split('&')
522 | for s in elements :
523 | param = s.split('=', 1)
524 | if len(param) > 0 :
525 | value = MicroWebSrv._unquote_plus(param[1]) if len(param) > 1 else ''
526 | res[MicroWebSrv._unquote_plus(param[0])] = value
527 | return res
528 |
529 | # ------------------------------------------------------------------------
530 |
531 | def ReadRequestContentAsJSON(self) :
532 | data = self.ReadRequestContent()
533 | if data :
534 | try :
535 | return loads(data.decode())
536 | except :
537 | pass
538 | return None
539 |
540 | # ============================================================================
541 | # ===( Class Response )======================================================
542 | # ============================================================================
543 |
544 | class _response :
545 |
546 | # ------------------------------------------------------------------------
547 |
548 | def __init__(self, client) :
549 | self._client = client
550 |
551 | # ------------------------------------------------------------------------
552 |
553 | def _write(self, data, strEncoding='ISO-8859-1') :
554 | if data :
555 | if type(data) == str :
556 | data = data.encode(strEncoding)
557 | data = memoryview(data)
558 | while data :
559 | n = self._client._socketfile.write(data)
560 | if n is None :
561 | return False
562 | data = data[n:]
563 | return True
564 | return False
565 |
566 | # ------------------------------------------------------------------------
567 |
568 | def _writeFirstLine(self, code) :
569 | reason = self._responseCodes.get(code, ('Unknown reason', ))[0]
570 | return self._write("HTTP/1.1 %s %s\r\n" % (code, reason))
571 |
572 | # ------------------------------------------------------------------------
573 |
574 | def _writeHeader(self, name, value) :
575 | return self._write("%s: %s\r\n" % (name, value))
576 |
577 | # ------------------------------------------------------------------------
578 |
579 | def _writeContentTypeHeader(self, contentType, charset=None) :
580 | if contentType :
581 | ct = contentType \
582 | + (("; charset=%s" % charset) if charset else "")
583 | else :
584 | ct = "application/octet-stream"
585 | self._writeHeader("Content-Type", ct)
586 |
587 | # ------------------------------------------------------------------------
588 |
589 | def _writeServerHeader(self) :
590 | self._writeHeader("Server", "MicroWebSrv by JC`zic")
591 |
592 | # ------------------------------------------------------------------------
593 |
594 | def _writeEndHeader(self) :
595 | return self._write("\r\n")
596 |
597 | # ------------------------------------------------------------------------
598 |
599 | def _writeBeforeContent(self, code, headers, contentType, contentCharset, contentLength) :
600 | self._writeFirstLine(code)
601 | if isinstance(headers, dict) :
602 | for header in headers :
603 | self._writeHeader(header, headers[header])
604 | if contentLength > 0 :
605 | self._writeContentTypeHeader(contentType, contentCharset)
606 | self._writeHeader("Content-Length", contentLength)
607 | self._writeServerHeader()
608 | self._writeHeader("Connection", "close")
609 | self._writeEndHeader()
610 |
611 | # ------------------------------------------------------------------------
612 |
613 | def WriteSwitchProto(self, upgrade, headers=None) :
614 | self._writeFirstLine(101)
615 | self._writeHeader("Connection", "Upgrade")
616 | self._writeHeader("Upgrade", upgrade)
617 | if isinstance(headers, dict) :
618 | for header in headers :
619 | self._writeHeader(header, headers[header])
620 | self._writeServerHeader()
621 | self._writeEndHeader()
622 | if self._client._socketfile is not self._client._socket :
623 | self._client._socketfile.flush() # CPython needs flush to continue protocol
624 |
625 | # ------------------------------------------------------------------------
626 |
627 | def WriteResponse(self, code, headers, contentType, contentCharset, content) :
628 | try :
629 | if content :
630 | if type(content) == str :
631 | content = content.encode(contentCharset)
632 | contentLength = len(content)
633 | else :
634 | contentLength = 0
635 | self._writeBeforeContent(code, headers, contentType, contentCharset, contentLength)
636 | if content :
637 | return self._write(content)
638 | return True
639 | except :
640 | return False
641 |
642 | # ------------------------------------------------------------------------
643 |
644 | def WriteResponsePyHTMLFile(self, filepath, headers=None, vars=None) :
645 | if 'MicroWebTemplate' in globals() :
646 | with open(filepath, 'r') as file :
647 | code = file.read()
648 | mWebTmpl = MicroWebTemplate(code, escapeStrFunc=MicroWebSrv.HTMLEscape, filepath=filepath)
649 | try :
650 | tmplResult = mWebTmpl.Execute(None, vars)
651 | return self.WriteResponse(200, headers, "text/html", "UTF-8", tmplResult)
652 | except Exception as ex :
653 | return self.WriteResponse( 500,
654 | None,
655 | "text/html",
656 | "UTF-8",
657 | self._execErrCtnTmpl % {
658 | 'module' : 'PyHTML',
659 | 'message' : str(ex)
660 | } )
661 | return self.WriteResponseNotImplemented()
662 |
663 | # ------------------------------------------------------------------------
664 |
665 | def WriteResponseFile(self, filepath, contentType=None, headers=None) :
666 | try :
667 | size = stat(filepath)[6]
668 | if size > 0 :
669 | with open(filepath, 'rb') as file :
670 | self._writeBeforeContent(200, headers, contentType, None, size)
671 | try :
672 | buf = bytearray(1024)
673 | while size > 0 :
674 | x = file.readinto(buf)
675 | if x < len(buf) :
676 | buf = memoryview(buf)[:x]
677 | if not self._write(buf) :
678 | return False
679 | size -= x
680 | return True
681 | except :
682 | self.WriteResponseInternalServerError()
683 | return False
684 | except :
685 | pass
686 | self.WriteResponseNotFound()
687 | return False
688 |
689 | # ------------------------------------------------------------------------
690 |
691 | def WriteResponseFileAttachment(self, filepath, attachmentName, headers=None) :
692 | if not isinstance(headers, dict) :
693 | headers = { }
694 | headers["Content-Disposition"] = "attachment; filename=\"%s\"" % attachmentName
695 | return self.WriteResponseFile(filepath, None, headers)
696 |
697 | # ------------------------------------------------------------------------
698 |
699 | def WriteResponseOk(self, headers=None, contentType=None, contentCharset=None, content=None) :
700 | return self.WriteResponse(200, headers, contentType, contentCharset, content)
701 |
702 | # ------------------------------------------------------------------------
703 |
704 | def WriteResponseJSONOk(self, obj=None, headers=None) :
705 | return self.WriteResponse(200, headers, "application/json", "UTF-8", dumps(obj))
706 |
707 | # ------------------------------------------------------------------------
708 |
709 | def WriteResponseRedirect(self, location) :
710 | headers = { "Location" : location }
711 | return self.WriteResponse(302, headers, None, None, None)
712 |
713 | # ------------------------------------------------------------------------
714 |
715 | def WriteResponseError(self, code) :
716 | responseCode = self._responseCodes.get(code, ('Unknown reason', ''))
717 | return self.WriteResponse( code,
718 | None,
719 | "text/html",
720 | "UTF-8",
721 | self._errCtnTmpl % {
722 | 'code' : code,
723 | 'reason' : responseCode[0],
724 | 'message' : responseCode[1]
725 | } )
726 |
727 | # ------------------------------------------------------------------------
728 |
729 | def WriteResponseJSONError(self, code, obj=None) :
730 | return self.WriteResponse( code,
731 | None,
732 | "application/json",
733 | "UTF-8",
734 | dumps(obj if obj else { }) )
735 |
736 | # ------------------------------------------------------------------------
737 |
738 | def WriteResponseNotModified(self) :
739 | return self.WriteResponseError(304)
740 |
741 | # ------------------------------------------------------------------------
742 |
743 | def WriteResponseBadRequest(self) :
744 | return self.WriteResponseError(400)
745 |
746 | # ------------------------------------------------------------------------
747 |
748 | def WriteResponseForbidden(self) :
749 | return self.WriteResponseError(403)
750 |
751 | # ------------------------------------------------------------------------
752 |
753 | def WriteResponseNotFound(self) :
754 | if self._client._microWebSrv._notFoundUrl :
755 | self.WriteResponseRedirect(self._client._microWebSrv._notFoundUrl)
756 | else :
757 | return self.WriteResponseError(404)
758 |
759 | # ------------------------------------------------------------------------
760 |
761 | def WriteResponseMethodNotAllowed(self) :
762 | return self.WriteResponseError(405)
763 |
764 | # ------------------------------------------------------------------------
765 |
766 | def WriteResponseInternalServerError(self) :
767 | return self.WriteResponseError(500)
768 |
769 | # ------------------------------------------------------------------------
770 |
771 | def WriteResponseNotImplemented(self) :
772 | return self.WriteResponseError(501)
773 |
774 | # ------------------------------------------------------------------------
775 |
776 | def FlashMessage(self, messageText, messageStyle='') :
777 | if 'MicroWebTemplate' in globals() :
778 | MicroWebTemplate.MESSAGE_TEXT = messageText
779 | MicroWebTemplate.MESSAGE_STYLE = messageStyle
780 |
781 | # ------------------------------------------------------------------------
782 |
783 | _errCtnTmpl = """\
784 |
785 |
786 | Error
787 |
788 |
789 | %(code)d %(reason)s
790 | %(message)s
791 |
792 |
793 | """
794 |
795 | # ------------------------------------------------------------------------
796 |
797 | _execErrCtnTmpl = """\
798 |
799 |
800 | Page execution error
801 |
802 |
803 | %(module)s page execution error
804 | %(message)s
805 |
806 |
807 | """
808 |
809 | # ------------------------------------------------------------------------
810 |
811 | _responseCodes = {
812 | 100: ('Continue', 'Request received, please continue'),
813 | 101: ('Switching Protocols',
814 | 'Switching to new protocol; obey Upgrade header'),
815 |
816 | 200: ('OK', 'Request fulfilled, document follows'),
817 | 201: ('Created', 'Document created, URL follows'),
818 | 202: ('Accepted',
819 | 'Request accepted, processing continues off-line'),
820 | 203: ('Non-Authoritative Information', 'Request fulfilled from cache'),
821 | 204: ('No Content', 'Request fulfilled, nothing follows'),
822 | 205: ('Reset Content', 'Clear input form for further input.'),
823 | 206: ('Partial Content', 'Partial content follows.'),
824 |
825 | 300: ('Multiple Choices',
826 | 'Object has several resources -- see URI list'),
827 | 301: ('Moved Permanently', 'Object moved permanently -- see URI list'),
828 | 302: ('Found', 'Object moved temporarily -- see URI list'),
829 | 303: ('See Other', 'Object moved -- see Method and URL list'),
830 | 304: ('Not Modified',
831 | 'Document has not changed since given time'),
832 | 305: ('Use Proxy',
833 | 'You must use proxy specified in Location to access this '
834 | 'resource.'),
835 | 307: ('Temporary Redirect',
836 | 'Object moved temporarily -- see URI list'),
837 |
838 | 400: ('Bad Request',
839 | 'Bad request syntax or unsupported method'),
840 | 401: ('Unauthorized',
841 | 'No permission -- see authorization schemes'),
842 | 402: ('Payment Required',
843 | 'No payment -- see charging schemes'),
844 | 403: ('Forbidden',
845 | 'Request forbidden -- authorization will not help'),
846 | 404: ('Not Found', 'Nothing matches the given URI'),
847 | 405: ('Method Not Allowed',
848 | 'Specified method is invalid for this resource.'),
849 | 406: ('Not Acceptable', 'URI not available in preferred format.'),
850 | 407: ('Proxy Authentication Required', 'You must authenticate with '
851 | 'this proxy before proceeding.'),
852 | 408: ('Request Timeout', 'Request timed out; try again later.'),
853 | 409: ('Conflict', 'Request conflict.'),
854 | 410: ('Gone',
855 | 'URI no longer exists and has been permanently removed.'),
856 | 411: ('Length Required', 'Client must specify Content-Length.'),
857 | 412: ('Precondition Failed', 'Precondition in headers is false.'),
858 | 413: ('Request Entity Too Large', 'Entity is too large.'),
859 | 414: ('Request-URI Too Long', 'URI is too long.'),
860 | 415: ('Unsupported Media Type', 'Entity body in unsupported format.'),
861 | 416: ('Requested Range Not Satisfiable',
862 | 'Cannot satisfy request range.'),
863 | 417: ('Expectation Failed',
864 | 'Expect condition could not be satisfied.'),
865 |
866 | 500: ('Internal Server Error', 'Server got itself in trouble'),
867 | 501: ('Not Implemented',
868 | 'Server does not support this operation'),
869 | 502: ('Bad Gateway', 'Invalid responses from another server/proxy.'),
870 | 503: ('Service Unavailable',
871 | 'The server cannot process the request due to a high load'),
872 | 504: ('Gateway Timeout',
873 | 'The gateway server did not receive a timely response'),
874 | 505: ('HTTP Version Not Supported', 'Cannot fulfill request.'),
875 | }
876 |
877 | # ============================================================================
878 | # ============================================================================
879 | # ============================================================================
880 |
881 |
--------------------------------------------------------------------------------
/microWebSrv2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jczic/MicroWebSrv/9909b830792d5d06cd1c34dce50985b3291eb0da/microWebSrv2.png
--------------------------------------------------------------------------------
/microWebTemplate.py:
--------------------------------------------------------------------------------
1 | """
2 | The MIT License (MIT)
3 | Copyright © 2018 Jean-Christophe Bos & HC² (www.hc2.fr)
4 | """
5 |
6 | import re
7 |
8 | class MicroWebTemplate :
9 |
10 | # ============================================================================
11 | # ===( Constants )============================================================
12 | # ============================================================================
13 |
14 | TOKEN_OPEN = '{{'
15 | TOKEN_CLOSE = '}}'
16 | TOKEN_OPEN_LEN = len(TOKEN_OPEN)
17 | TOKEN_CLOSE_LEN = len(TOKEN_CLOSE)
18 |
19 | INSTRUCTION_PYTHON = 'py'
20 | INSTRUCTION_IF = 'if'
21 | INSTRUCTION_ELIF = 'elif'
22 | INSTRUCTION_ELSE = 'else'
23 | INSTRUCTION_FOR = 'for'
24 | INSTRUCTION_END = 'end'
25 | INSTRUCTION_INCLUDE = 'include'
26 |
27 | MESSAGE_TEXT = ''
28 | MESSAGE_STYLE = ''
29 |
30 | # ============================================================================
31 | # ===( Constructor )==========================================================
32 | # ============================================================================
33 |
34 | def __init__(self, code, escapeStrFunc=None, filepath='') :
35 | self._code = code
36 | self._escapeStrFunc = escapeStrFunc
37 | self._filepath = filepath
38 | self._pos = 0
39 | self._endPos = len(code)-1
40 | self._line = 1
41 | self._reIdentifier = re.compile(r'[a-zA-Z_][a-zA-Z0-9_]*$')
42 | self._pyGlobalVars = { }
43 | self._pyLocalVars = { }
44 | self._rendered = ''
45 | self._instructions = {
46 | MicroWebTemplate.INSTRUCTION_PYTHON : self._processInstructionPYTHON,
47 | MicroWebTemplate.INSTRUCTION_IF : self._processInstructionIF,
48 | MicroWebTemplate.INSTRUCTION_ELIF : self._processInstructionELIF,
49 | MicroWebTemplate.INSTRUCTION_ELSE : self._processInstructionELSE,
50 | MicroWebTemplate.INSTRUCTION_FOR : self._processInstructionFOR,
51 | MicroWebTemplate.INSTRUCTION_END : self._processInstructionEND,
52 | MicroWebTemplate.INSTRUCTION_INCLUDE: self._processInstructionINCLUDE,
53 | }
54 |
55 | # ============================================================================
56 | # ===( Functions )============================================================
57 | # ============================================================================
58 |
59 | def Validate(self, pyGlobalVars=None, pyLocalVars=None) :
60 | try :
61 | self._parseCode(pyGlobalVars, pyLocalVars, execute=False)
62 | return None
63 | except Exception as ex :
64 | return str(ex)
65 |
66 | # ----------------------------------------------------------------------------
67 |
68 | def Execute(self, pyGlobalVars=None, pyLocalVars=None) :
69 | try :
70 | self._parseCode(pyGlobalVars, pyLocalVars, execute=True)
71 | return self._rendered
72 | except Exception as ex :
73 | raise Exception(str(ex))
74 |
75 | # ============================================================================
76 | # ===( Utils )===============================================================
77 | # ============================================================================
78 |
79 | def _parseCode(self, pyGlobalVars, pyLocalVars, execute) :
80 | if pyGlobalVars:
81 | self._pyGlobalVars.update(pyGlobalVars)
82 | if pyLocalVars:
83 | self._pyLocalVars.update(pyLocalVars)
84 | self._pyLocalVars['MESSAGE_TEXT'] = MicroWebTemplate.MESSAGE_TEXT
85 | self._pyLocalVars['MESSAGE_STYLE'] = MicroWebTemplate.MESSAGE_STYLE
86 | self._rendered = ''
87 | newTokenToProcess = self._parseBloc(execute)
88 | if newTokenToProcess is not None :
89 | raise Exception( '"%s" instruction is not valid here (line %s)'
90 | % (newTokenToProcess, self._line) )
91 | MicroWebTemplate.MESSAGE_TEXT = ''
92 | MicroWebTemplate.MESSAGE_STYLE = ''
93 |
94 | # ----------------------------------------------------------------------------
95 |
96 | def _parseBloc(self, execute) :
97 | while self._pos <= self._endPos :
98 | c = self._code[self._pos]
99 | if c == MicroWebTemplate.TOKEN_OPEN[0] and \
100 | self._code[ self._pos : self._pos + MicroWebTemplate.TOKEN_OPEN_LEN ] == MicroWebTemplate.TOKEN_OPEN :
101 | self._pos += MicroWebTemplate.TOKEN_OPEN_LEN
102 | tokenContent = ''
103 | x = self._pos
104 | while True :
105 | if x > self._endPos :
106 | raise Exception("%s is missing (line %s)" % (MicroWebTemplate.TOKEN_CLOSE, self._line))
107 | c = self._code[x]
108 | if c == MicroWebTemplate.TOKEN_CLOSE[0] and \
109 | self._code[ x : x + MicroWebTemplate.TOKEN_CLOSE_LEN ] == MicroWebTemplate.TOKEN_CLOSE :
110 | self._pos = x + MicroWebTemplate.TOKEN_CLOSE_LEN
111 | break
112 | elif c == '\n' :
113 | self._line += 1
114 | tokenContent += c
115 | x += 1
116 | newTokenToProcess = self._processToken(tokenContent, execute)
117 | if newTokenToProcess is not None :
118 | return newTokenToProcess
119 | continue
120 | elif c == '\n' :
121 | self._line += 1
122 | if execute :
123 | self._rendered += c
124 | self._pos += 1
125 | return None
126 |
127 | # ----------------------------------------------------------------------------
128 |
129 | def _processToken(self, tokenContent, execute) :
130 | tokenContent = tokenContent.strip()
131 | parts = tokenContent.split(' ', 1)
132 | instructName = parts[0].strip()
133 | instructBody = parts[1].strip() if len(parts) > 1 else None
134 | if len(instructName) == 0 :
135 | raise Exception( '"%s %s" : instruction is missing (line %s)'
136 | % (MicroWebTemplate.TOKEN_OPEN, MicroWebTemplate.TOKEN_CLOSE, self._line) )
137 | newTokenToProcess = None
138 | if instructName in self._instructions :
139 | newTokenToProcess = self._instructions[instructName](instructBody, execute)
140 | elif execute :
141 | try :
142 | s = str( eval( tokenContent,
143 | self._pyGlobalVars,
144 | self._pyLocalVars ) )
145 | if (self._escapeStrFunc is not None) :
146 | self._rendered += self._escapeStrFunc(s)
147 | else :
148 | self._rendered += s
149 | except Exception as ex :
150 | raise Exception('%s (line %s)' % (str(ex), self._line))
151 | return newTokenToProcess
152 |
153 | # ----------------------------------------------------------------------------
154 |
155 | def _processInstructionPYTHON(self, instructionBody, execute) :
156 | if instructionBody is not None :
157 | raise Exception( 'Instruction "%s" is invalid (line %s)'
158 | % (MicroWebTemplate.INSTRUCTION_PYTHON, self._line) )
159 | pyCode = ''
160 | while True :
161 | if self._pos > self._endPos :
162 | raise Exception( '"%s" instruction is missing (line %s)'
163 | % (MicroWebTemplate.INSTRUCTION_END, self._line) )
164 | c = self._code[self._pos]
165 | if c == MicroWebTemplate.TOKEN_OPEN[0] and \
166 | self._code[ self._pos : self._pos + MicroWebTemplate.TOKEN_OPEN_LEN ] == MicroWebTemplate.TOKEN_OPEN :
167 | self._pos += MicroWebTemplate.TOKEN_OPEN_LEN
168 | tokenContent = ''
169 | x = self._pos
170 | while True :
171 | if x > self._endPos :
172 | raise Exception("%s is missing (line %s)" % (MicroWebTemplate.TOKEN_CLOSE, self._line))
173 | c = self._code[x]
174 | if c == MicroWebTemplate.TOKEN_CLOSE[0] and \
175 | self._code[ x : x + MicroWebTemplate.TOKEN_CLOSE_LEN ] == MicroWebTemplate.TOKEN_CLOSE :
176 | self._pos = x + MicroWebTemplate.TOKEN_CLOSE_LEN
177 | break
178 | elif c == '\n' :
179 | self._line += 1
180 | tokenContent += c
181 | x += 1
182 | tokenContent = tokenContent.strip()
183 | if tokenContent == MicroWebTemplate.INSTRUCTION_END :
184 | break
185 | raise Exception( '"%s" is a bad instruction in a python bloc (line %s)'
186 | % (tokenContent, self._line) )
187 | elif c == '\n' :
188 | self._line += 1
189 | if execute :
190 | pyCode += c
191 | self._pos += 1
192 | if execute :
193 | lines = pyCode.split('\n')
194 | indent = ''
195 | for line in lines :
196 | if len(line.strip()) > 0 :
197 | for c in line :
198 | if c == ' ' or c == '\t' :
199 | indent += c
200 | else :
201 | break
202 | break
203 | pyCode = ''
204 | for line in lines :
205 | if line.find(indent) == 0 :
206 | line = line[len(indent):]
207 | pyCode += line + '\n'
208 | try :
209 | exec(pyCode, self._pyGlobalVars, self._pyLocalVars)
210 | except Exception as ex :
211 | raise Exception('%s (line %s)' % (str(ex), self._line))
212 | return None
213 |
214 | # ----------------------------------------------------------------------------
215 |
216 | def _processInstructionIF(self, instructionBody, execute) :
217 | if instructionBody is not None :
218 | if execute :
219 | try :
220 | if (' ' not in instructionBody) and \
221 | ('=' not in instructionBody) and \
222 | ('<' not in instructionBody) and \
223 | ('>' not in instructionBody) and \
224 | (instructionBody not in self._pyGlobalVars) and \
225 | (instructionBody not in self._pyLocalVars):
226 | result = False
227 | else:
228 | result = bool(eval(instructionBody, self._pyGlobalVars, self._pyLocalVars))
229 | except Exception as ex :
230 | raise Exception('%s (line %s)' % (str(ex), self._line))
231 | else :
232 | result = False
233 | newTokenToProcess = self._parseBloc(execute and result)
234 | if newTokenToProcess is not None :
235 | if newTokenToProcess == MicroWebTemplate.INSTRUCTION_END :
236 | return None
237 | elif newTokenToProcess == MicroWebTemplate.INSTRUCTION_ELSE :
238 | newTokenToProcess = self._parseBloc(execute and not result)
239 | if newTokenToProcess is not None :
240 | if newTokenToProcess == MicroWebTemplate.INSTRUCTION_END :
241 | return None
242 | raise Exception( '"%s" instruction waited (line %s)'
243 | % (MicroWebTemplate.INSTRUCTION_END, self._line) )
244 | raise Exception( '"%s" instruction is missing (line %s)'
245 | % (MicroWebTemplate.INSTRUCTION_END, self._line) )
246 | elif newTokenToProcess == MicroWebTemplate.INSTRUCTION_ELIF :
247 | self._processInstructionIF(self._elifInstructionBody, execute and not result)
248 | return None
249 | raise Exception( '"%s" instruction waited (line %s)'
250 | % (MicroWebTemplate.INSTRUCTION_END, self._line) )
251 | raise Exception( '"%s" instruction is missing (line %s)'
252 | % (MicroWebTemplate.INSTRUCTION_END, self._line) )
253 | raise Exception( '"%s" alone is an incomplete syntax (line %s)'
254 | % (MicroWebTemplate.INSTRUCTION_IF, self._line) )
255 |
256 | # ----------------------------------------------------------------------------
257 |
258 | def _processInstructionELIF(self, instructionBody, execute) :
259 | if instructionBody is None :
260 | raise Exception( '"%s" alone is an incomplete syntax (line %s)'
261 | % (MicroWebTemplate.INSTRUCTION_ELIF, self._line) )
262 | self._elifInstructionBody = instructionBody
263 | return MicroWebTemplate.INSTRUCTION_ELIF
264 |
265 | # ----------------------------------------------------------------------------
266 |
267 | def _processInstructionELSE(self, instructionBody, execute) :
268 | if instructionBody is not None :
269 | raise Exception( 'Instruction "%s" is invalid (line %s)'
270 | % (MicroWebTemplate.INSTRUCTION_ELSE, self._line) )
271 | return MicroWebTemplate.INSTRUCTION_ELSE
272 |
273 | # ----------------------------------------------------------------------------
274 |
275 | def _processInstructionFOR(self, instructionBody, execute) :
276 | if instructionBody is not None :
277 | parts = instructionBody.split(' ', 1)
278 | identifier = parts[0].strip()
279 | if self._reIdentifier.match(identifier) is not None and len(parts) > 1 :
280 | parts = parts[1].strip().split(' ', 1)
281 | if parts[0] == 'in' and len(parts) > 1 :
282 | expression = parts[1].strip()
283 | newTokenToProcess = None
284 | beforePos = self._pos
285 | if execute :
286 | try :
287 | result = eval(expression, self._pyGlobalVars, self._pyLocalVars)
288 | except :
289 | raise Exception('%s (line %s)' % (str(expression), self._line))
290 | if execute and len(result) > 0 :
291 | for x in result :
292 | self._pyLocalVars[identifier] = x
293 | self._pos = beforePos
294 | newTokenToProcess = self._parseBloc(True)
295 | if newTokenToProcess != MicroWebTemplate.INSTRUCTION_END :
296 | break
297 | else :
298 | newTokenToProcess = self._parseBloc(False)
299 | if newTokenToProcess is not None :
300 | if newTokenToProcess == MicroWebTemplate.INSTRUCTION_END :
301 | return None
302 | raise Exception( '"%s" instruction waited (line %s)'
303 | % (MicroWebTemplate.INSTRUCTION_END, self._line) )
304 | raise Exception( '"%s" instruction is missing (line %s)'
305 | % (MicroWebTemplate.INSTRUCTION_END, self._line) )
306 | raise Exception( '"%s %s" is an invalid syntax'
307 | % (MicroWebTemplate.INSTRUCTION_FOR, instructionBody) )
308 | raise Exception( '"%s" alone is an incomplete syntax (line %s)'
309 | % (MicroWebTemplate.INSTRUCTION_FOR, self._line) )
310 |
311 | # ----------------------------------------------------------------------------
312 |
313 | def _processInstructionEND(self, instructionBody, execute) :
314 | if instructionBody is not None :
315 | raise Exception( 'Instruction "%s" is invalid (line %s)'
316 | % (MicroWebTemplate.INSTRUCTION_END, self._line) )
317 | return MicroWebTemplate.INSTRUCTION_END
318 |
319 | # ----------------------------------------------------------------------------
320 |
321 | def _processInstructionINCLUDE(self, instructionBody, execute) :
322 | if not instructionBody :
323 | raise Exception( '"%s" alone is an incomplete syntax (line %s)' % (MicroWebTemplate.INSTRUCTION_INCLUDE, self._line) )
324 | filename = instructionBody.replace('"','').replace("'",'').strip()
325 | idx = self._filepath.rindex('/')
326 | if idx >= 0 :
327 | filename = self._filepath[:idx+1] + filename
328 | with open(filename, 'r') as file :
329 | includeCode = file.read()
330 |
331 | self._code = self._code[:self._pos] + includeCode + self._code[self._pos:]
332 | self._endPos += len(includeCode)
333 |
334 | # ============================================================================
335 | # ============================================================================
336 | # ============================================================================
337 |
--------------------------------------------------------------------------------
/www/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jczic/MicroWebSrv/9909b830792d5d06cd1c34dce50985b3291eb0da/www/favicon.ico
--------------------------------------------------------------------------------
/www/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 | Page de test MicroWebSrv
8 | Page de test MicroWebSrv
13 | Hello !
14 |
15 | Lorem ipsum dolor sit amet, consectetur adipiscing elit. Duis eget ligula quis libero mollis dapibus. Suspendisse potenti. Nullam facilisis neque et sem. Proin placerat adipiscing urna. Aenean sollicitudin. Mauris lorem erat, fringilla quis, sagittis a, varius sed, nunc. Pellentesque ligula. Nullam egestas eleifend turpis. Vivamus ac sapien. Sed venenatis, ligula ut scelerisque vehicula, erat tellus euismod ipsum, eget faucibus tortor arcu et lectus. Vivamus vel purus. Fusce dignissim tortor quis diam elementum fermentum. Mauris eleifend lorem vel arcu. Vivamus tempus faucibus lectus. Curabitur volutpat ornare mi. Curabitur ac libero. Sed eu elit ac metus egestas iaculis.
16 |
17 | TEST
4 |
5 |
6 | BEGIN
7 | {{ py }}
8 | def _testFunction(x) :
9 | return "IN TEST FUNCTION %s" % x
10 | {{ end }}
11 |
12 | {{ for toto in range(3) }}
13 | This is an HTML test...
21 | {{ _testFunction(100) }}JC :')
33 |
34 |
35 |
--------------------------------------------------------------------------------
/www/wstest.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 | MicroWebSocket Test
8 |
9 |
10 |
72 |
73 |
74 | MicroWebSocket Test :
75 |
76 |
77 |
78 |
--------------------------------------------------------------------------------
10 | 
11 | 
22 |