asynchronous ssl esp32 Python websockets iot template-engine cors websocket-server web-server routes HTTP websocket micropython async
Need help with MicroWebSrv2?
Click the “chat” button below for chat support from the developer who created it, or find similar developers for support.
jczic

Description

The last Micro Web Server for IoTs (MicroPython) or large servers (CPython), that supports WebSockets, routes, template engine and with really optimized architecture (mem allocations, async I/Os). Ready for ESP32, STM32 on Pyboard, Pycom's chipsets (WiPy, LoPy, ...). Robust, efficient and documented!

212 Stars 32 Forks MIT License 129 Commits 18 Opened issues

Services available

Need anything else?

New microWebSrv2

Release Size MicroPython Python License


MicroWebSrv2 is the new powerful embedded Web Server for MicroPython and CPython that supports route handlers, modules like WebSockets or PyhtmlTemplate and a lot of simultaneous requests (in thousands!).

Fully asynchronous, its connections and memory management are very optimized and truly fast.

Mostly used on Pycom WiPy, ESP32, STM32 on Pyboard, ... Robust and efficient! (see Features)

:smallorangediamond: Download the latest version (Zip)



                _               __    __     _     __            ____  
      _ __ ___ (_) ___ _ __ ___/ / /\ \ \___| |__ / _\_ ____   _|___ \ 
     | '_ ` _ \| |/ __| '__/ _ \ \/  \/ / _ | '_ \\ \| '__\ \ / / __) |
     | | | | | | | (__| | | (_) \  /\  |  __| |_) _\ | |   \ V / / __/ 
     |_| |_| |_|_|\___|_|  \___/ \/  \/ \___|_.__/\__|_|    \_/ |_____|  JC`zic & HC²




:bookmark_tabs:  Table of contents


:anger:  About

This project follows the embedded MicroWebSrv, which is mainly used on microcontrollers such as Pycom, ESP32 and STM32 on Pyboards.

In a need for scalability and to meet the IoT universe, microWebSrv2 was developed as a new project and has been completely redesigned to be much more robust and efficient that its predecessor.

Internal mechanisms works directly at I/O level, are fully asynchronous from end to end, and manages the memory in a highly optimized way.
Also, architecture makes its integration very easy and the source code, MIT licensed, remains really small.


:rocket:  Features

  • Embed microWebSrv2 into your microcontrollers as a powerful web server.

  • Benefit from a fully asynchronous architecture that allows to process many concurrent requests very quickly.

  • Use multiple worker threads to parallelize simultaneous processes.

  • Adjust settings to fine-tune resources usage and sizing pre-allocated memory.

  • Load additional modules to extend the server's functionalities.

  • Customize the management of centralized logs.

  • Apply SSL/TLS security layer and certificate on web connections (https mode).

  • Define web routes with variable arguments in order to be able to process the targeted requests.

  • Receive any type of request such as

    GET
    ,
    HEAD
    ,
    POST
    ,
    PUT
    ,
    DELETE
    ,
    OPTIONS
    ,
    PATCH
    , ...
  • Use the route resolver (from the path) and the path builder (from the route) for convenience.

  • Increase loading speed by automatically allowing web clients to cache static files.

  • Receive name/value pairs from URL encoded forms.

  • Send and receive JSON objects and use them to create a RESTful API style.

  • Play with AjAX requests to interact quickly with a web application.

  • Define the origin of resources and allow all values of CORS pre-flight requests.

  • Verify that a request is successfully authenticated by the Basic or Bearer method.

  • Reduce the number of persistent connections per web client with keep-alive mode support.

  • Respond to a request by using a data stream as content, sent with known length or in chunked transfer-encoding.

  • Use a file to respond to a request that will be treated as on-the-fly content or as an attachment to download.

  • Take advantage of the WebSockets module to exchange messages in real time via WS or secured WSS connection.

  • Create .pyhtml pages for an HTML rendering with integrated Python using the PyhtmlTemplate module.


:electric_plug:  Install

  • Solution 1 Run:
    pip3 install --user git+https://github.com/jczic/MicroWebSrv2.git#egg=MicroWebSrv2
    git clone https://github.com/jczic/MicroWebSrv2.git
    and run:
    cd MicroWebSrv2 && pip install --user .
  • Solution 3, download the ZIP file and extract it to a folder of your choice.

:verticaltrafficlight:  Demo

  1. Start the example: ```sh

    python3 main.py ```

  2. Open your web browser at:

WebSockets Chat


:gear:  Usage

from MicroWebSrv2 import *
from time         import sleep

mws2 = MicroWebSrv2() mws2.StartManaged()

Main program loop until keyboard interrupt,

try : while True : sleep(1) except KeyboardInterrupt : mws2.Stop()


:books:  Documentation

- ## MicroWebSrv2 package

The Python package comes with the following files:
  - :small_red_triangle_down: **/MicroWebSrv2**
    - :small_orange_diamond: \_\_init\_\_.py
    - :small_orange_diamond: microWebSrv2.py
    - :small_orange_diamond: webRoute.py
    - :small_orange_diamond: httpRequest.py
    - :small_orange_diamond: httpResponse.py
    - :small_blue_diamond: **/libs**
      - :small_orange_diamond: XAsyncSockets.py
      - :small_orange_diamond: urlUtils.py
    - :small_blue_diamond: **/mods**
      - :small_orange_diamond: WebSockets.py
      - :small_orange_diamond: PyhtmlTemplate.py


- ## Working with microWebSrv2

To work with **microWebSrv2**, you must first import the package as follows:
```python
from MicroWebSrv2 import *
```

There are 5 main elements with which you will work:

Now, you have everything you need to continue :sunglasses:


  • Asynchronous logic

    microWebSrv2 is based on a fully asynchronous I/Os logic.

    This means that many requests and responses can be processed concurrently, allowing other necessary processing at any time within a single thread.

    In addition, it is possible to use several shared workers in order to be able to parallelize processes that could be blocking.

    Finally, memory buffers required for data processing are pre-allocated as best as possible to maximize performance and prevent excessive memory requirements.

    Thus, it is possible to maintain several thousand persistent connections but also, to benefit from a low consumption of resources on embedded platforms.

    > microWebSrv2 leans on the XAsyncSockets layer.


  • Configuring web server

    Before starting microWebSrv2 to listen to web requests, it is important to configure it correctly.

    • If you want to change the default server port or bind IP address, you must set the BindAddress property.

      mws2.BindAddress = ('192.168.0.1', 12345)
    • If you want to define an another directory for web files, you must set the RootPath property.

      mws2.RootPath = 'webfiles/root'
    • If you want a secure https web server, you must call the EnableSSL method.

      mws2.EnableSSL(certFile='certificate.crt', keyFile='private-key.key')
    • If you want to redirect resources not found, you must set the NotFoundURL property.

      mws2.NotFoundURL = '/'   # relative or absolute URL
    • If you want to set a pre-configured setting, you can call one of the following methods:

    • If you want to set your custom settings, you can adjust the following properties:

    • If you want to change the default timeout to wait for requests data, you must set the RequestsTimeoutSec property.

      mws2.RequestsTimeoutSec = 10
    • If you want to intercept logs to process them, you must set the OnLogging callback.

      def OnMWS2Logging(microWebSrv2, msg, msgType) :
          print('Log from custom function: %s' % msg)
      
      mws2.OnLogging = OnMWS2Logging

    • Default pages

      Default pages are used as resources when requested paths point to directories.

      Page filename
      index.html
      index.htm
      default.html
      default.htm

      > It is possible to add new default pages globally by calling MicroWebSrv2.AddDefaultPage static method.


    • MIME types

      MIME types allow specific files as readable resources and that are transmitted with the corresponding content type.

      Filename extension MIME type
      .txt text/plain
      .htm text/html
      .html text/html
      .css text/css
      .csv text/csv
      .js application/javascript
      .xml application/xml
      .xhtml application/xhtml+xml
      .json application/json
      .zip application/zip
      .pdf application/pdf
      .ts application/typescript
      .woff font/woff
      .woff2 font/woff2
      .ttf font/ttf
      .otf font/otf
      .jpg image/jpeg
      .jpeg image/jpeg
      .png image/png
      .gif image/gif
      .svg image/svg+xml
      .ico image/x-icon

      > It is possible to add new MIME types globally by calling MicroWebSrv2.AddMimeType static method.


  • Starting web server

    To start microWebSrv2 server, you must use one of the following methods:

    • Start in a pool:
      The web server uses an existing asynchronous pool.
      If you want to have more than one server, this is the right solution.
      > For more documentation, see StartInPool(...) method.
      > If you want details about pools, check the GitHub repository of XAsyncSockets library.

    • Start in a managed pool:
      The web server automatically creates a new managed asynchronous pool and uses it.
      If you only need one server without more specific code, this is the right solution.
      However, you will need to define some pool sizing parameters.
      In this mode, a call to mws2.Stop() will release the pool.
      > For more documentation, see StartManaged(...) method.

    :cyclone: Example to start a dual http/https web server:

    from MicroWebSrv2 import *
    from time         import sleep
    
    xasPool  = XAsyncSocketsPool()
    srvHttp  = MicroWebSrv2()
    srvHttps = MicroWebSrv2()
    
    srvHttps.EnableSSL( certFile = 'SSL-Cert/openhc2.crt',
                        keyFile  = 'SSL-Cert/openhc2.key' )
    
    srvHttp .StartInPool(xasPool)
    srvHttps.StartInPool(xasPool)
    
    xasPool.AsyncWaitEvents(threadsCount=1)
    
    try :
        while True :
            sleep(1)
    except KeyboardInterrupt :
        srvHttp .Stop()
        srvHttps.Stop()
        xasPool .StopWaitEvents()

  • Handling web routes

    microWebSrv2 have an easy and efficient web route system.
    A simple handler function with a decorator allows you to process requests.

    :cyclone: Example of a processing handler:

    @WebRoute(GET, '/test')
    def RequestTest(microWebSrv2, request) :
        request.Response.ReturnOkJSON({
            'ClientAddr' : request.UserAddress,
            'Accept'     : request.Accept,
            'UserAgent'  : request.UserAgent
        })

    > For more documentation, see Web Routes section.


  • SSL/TLS security (HTTPS)

    microWebSrv2 allow web server to apply the SSL/TLS security layer.
    In this case, a certificate and its private key must be given (with an optional PEM file).

    If you want to test https mode, uncomment the mws2.EnableSSL(...) call in main.py file.
    After restarting the demo program, open your browser at the following address:
    https://localhost

    :warning: The ssl library must be implements SSLContext on Python version to support secured web server.


- ## About XAsyncSockets layer

**XAsyncSockets** is an efficient Python/MicroPython library of managed asynchronous sockets.  
> Available under MIT license on GitHub (same author):  
  [https://github.com/jczic/XAsyncSockets](https://github.com/jczic/XAsyncSockets)

XAsyncSockets layer provides the following features:

  • Managed asynchronous sockets in a pool (up to thousands!)
  • Works directly with I/O to receive and send very quickly
  • Supports very large number of simultaneous TCP connections
  • Supports concurrent synchronous processing operations if necessary (threaded)
  • Implementation of TCP servers
  • Implementation of TCP clients
  • Implementation of UDP datagrams (sender and/or receiver)
  • TCP client can event after a specified size of data or a text line received
  • Each connections and receivings can waiting during a specified time
  • The reasons of TCP client closures are returned
  • Really robust, very fast and easy to use
  • Compatible with MicroPython implementation (sockets layer, FiFo queue, perf counter)

- ## MicroWebSrv2 Class

**MicroWebSrv2** is the main class and is needed to create an instance of web server:
```python
mws2 = MicroWebSrv2()
```


  • MicroWebSrv2 static methods

    :arrow_forward: MicroWebSrv2.LoadModule(...)

    @staticmethod
    def LoadModule(modName)
    # Loads a global and dedicated module for all instances of MicroWebSrv2.
    #   - Returns the instantiated class of the module.
    #     This instance can be used to configure global parameters and callbacks.
    #   - <modname> is the name of module and must be a not empty string.
    # An exception will be raised if an error occurs.

    :arrow_forward: MicroWebSrv2.HTMLEscape(...)

    @staticmethod
    def HTMLEscape(s)
    # Escapes HTML special characters of a text to use it in HTML code.
    #   - Returns the escaped string of <s>.
    #   - <s> is a text that must be escaped and must be a string.
    # An exception can be raised if <s> is not correct.

    :arrow_forward: MicroWebSrv2.AddDefaultPage(...)

    @staticmethod
    def AddDefaultPage(filename)
    # Adds a new default page that it can be returned when a directory resource is requested.
    # Default pages are searched by order in list and file must be found in the directory.
    # Ex: AddDefaultPage('home.html')
    #   - No return value.
    #   - <filename> is the name of page file that will be searched and must be a not empty string.
    # An exception can be raised if <filename> is not correct.

    :arrow_forward: MicroWebSrv2.AddMimeType(...)

    @staticmethod
    def AddMimeType(ext, mimeType)
    # Adds a new MIME type to support specified file type and response content type.
    # Ex: AddMimeType('.tar', 'application/x-tar')
    #   - No return value.
    #   - <ext> is the file extention including the dot and must be a not empty string.
    #   - <mimetype> is the name of MIME type and must be a not empty string.
    # An exception can be raised if arguments are not correct.

    :arrow_forward: MicroWebSrv2.GetMimeTypeFromFilename(...)

    @staticmethod
    def GetMimeTypeFromFilename(filename)
    # Obtains the name of MIME type corresponding to a filename.
    #   - Returns the name of MIME type found in string, returns None otherwise.
    #   - <filename> is a path to a file and must be a not empty string.

  • MicroWebSrv2 instance methods

    :arrow_forward: mws2.StartInPool(...)

    def StartInPool(self, asyncSocketsPool)
    # Starts the web server in an existing asynchronous pool.
    #   - No return value.
    #   - <asyncsocketspool> is the asynchronous pool and must be an instantiated class of XAsyncSocketsPool.
    # An exception will be raised if an error occurs.

    :arrow_forward: mws2.StartManaged(...)

    def StartManaged(self, parllProcCount=1, procStackSize=0)
    # Starts the web server in a new and managed asynchronous pool.
    #   - No return value.
    #   - <parllproccount> is the count of parallel processes and must be a positive integer or zero.
    #   - <procstacksize> is the stack size for each parallelized processes and must be a positive integer or zero.
    # If <parllproccount> is 0, the calling thread is used and blocked to process all http connections.
    # If <parllproccount> is 1, only one thread is reserved to process all http connections.
    # If <parllproccount> is greater than 1, multiple threads are reserved to share and process all http connections.
    # If <procstacksize>  is 0, the default stack size is used on CPython and a value of 8192 is used on MicroPython.
    # A minimum value of 8*1024 is recommended for <procstacksize> but on CPython, the minimum value must be of 32*1024.
    # An exception will be raised if an error occurs.

    :arrow_forward: mws2.Stop(...)

    def Stop(self)
    # Stops the web server.
    # If the server has started in managed mode, this automatically releases the asynchronous pool.
    #   - No return value.

    :arrow_forward: mws2.Log(...)

    def Log(self, msg, msgType)
    # Logs the message of the specified type to the output or by calling the OnLogging callback.
    #   - No return value.
    #   - <msg> is the message to log and will be converted to string.
    #   - <msgtype> can take following values:
    #      - MicroWebSrv2.DEBUG
    #      - MicroWebSrv2.INFO
    #      - MicroWebSrv2.WARNING
    #      - MicroWebSrv2.ERROR

    :arrow_forward: mws2.ResolvePhysicalPath(...)

    def ResolvePhysicalPath(self, urlPath)
    # Resolves the specified relative URL path to the physical path.
    #   - Returns the physical path found or None.
    #   - <urlpath> is the relative URL path to resolve and must be a not empty string.
    # An exception can be raised if <urlpath> is not correct.

    :arrow_forward: mws2.EnableSSL(...)

    def EnableSSL(self, certFile, keyFile, caFile=None)
    # Configures the web server to apply the SSL/TLS security layer (https).
    # Warning, the ssl library must be implements SSLContext on Python version to support secured web server.
    #   - No return value.
    #   - <certfile> is the path of the certificate file and must be a not empty string.
    #   - <keyfile> is the path of the private key file and must be a not empty string.
    #   - <cafile> is the path of a PEM file and must be a not empty string or None.
    # If the web server port in BindAddress is 80 (default http), it automatically switches to port 443 (default https).
    # An exception will be raised if an error occurs.

    :arrow_forward: mws2.DisableSSL(...)

    def DisableSSL(self)
    # Configures the web server as SSL/TLS web server (https).
    #   - No return value.
    # If the web server port in BindAddress is 443 (default https), it automatically switches to port 80 (default http).
    # An exception can be raised if an error occurs.

    :arrow_forward: mws2.SetEmbeddedConfig(...)

    def SetEmbeddedConfig(self)
    # Configures the web server with optimized parameters for an embedded deployment.
    #   - No return value.
    # Parameters set:
    #   - ConnQueueCapacity       = 8
    #   - BufferSlotsCount        = 16
    #   - BufferSlotSize          = 1024
    #   - KeepAllocBufferSlots    = True
    #   - MaxRequestContentLength = 16*1024
    # An exception can be raised if an error occurs.

    :arrow_forward: mws2.SetLightConfig(...)

    def SetLightConfig(self)
    # Configures the web server with optimized parameters for a light deployment.
    #   - No return value.
    # Parameters set:
    #   - ConnQueueCapacity       = 64
    #   - BufferSlotsCount        = 128
    #   - BufferSlotSize          = 1024
    #   - KeepAllocBufferSlots    = True
    #   - MaxRequestContentLength = 512*1024
    # An exception can be raised if an error occurs.

    :arrow_forward: mws2.SetNormalConfig(...)

    def SetNormalConfig(self)
    # Configures the web server with optimized parameters for a normal deployment.
    # It is the default configuration when MicroWebSrv2 class is created.
    #   - No return value.
    # Parameters set:
    #   - ConnQueueCapacity       = 256
    #   - BufferSlotsCount        = 512
    #   - BufferSlotSize          = 4*1024
    #   - KeepAllocBufferSlots    = True
    #   - MaxRequestContentLength = 2*1024*1024
    # An exception can be raised if an error occurs.

    :arrow_forward: mws2.SetLargeConfig(...)

    def SetLargeConfig(self)
    # Configures the web server with optimized parameters for a large deployment.
    #   - No return value.
    # Parameters set:
    #   - ConnQueueCapacity       = 512
    #   - BufferSlotsCount        = 2*1024
    #   - BufferSlotSize          = 16*1024
    #   - KeepAllocBufferSlots    = True
    #   - MaxRequestContentLength = 8*1024*1024
    # An exception can be raised if an error occurs.

  • MicroWebSrv2 properties

    Name Type Get Set Description
    IsRunning bool :ballot_box_with_check: - Indicates that the server is running.
    ConnQueueCapacity int :ballot_box_with_check: :ballot_box_with_check: Queue capacity of the TCP server (backlog).
    BufferSlotsCount int :ballot_box_with_check: :ballot_box_with_check: Number of pre-allocated memory buffer slots.
    BufferSlotSize int :ballot_box_with_check: :ballot_box_with_check: Size of each pre-allocated memory buffer slots.
    KeepAllocBufferSlots bool :ballot_box_with_check: :ballot_box_with_check: Maintains the allocation of memory buffer slots.
    MaxRequestContentLength int :ballot_box_with_check: :ballot_box_with_check: Maximum content length who can be processed by a request.
    BindAddress tuple :ballot_box_with_check: :ballot_box_with_check: Local bind address of the TCP server such as a tuple of (str_ip_addr, int_port).
    IsSSLEnabled bool :ballot_box_with_check: - Indicates that SSL/TLS security layer with certificate is currently enabled.
    RootPath str :ballot_box_with_check: :ballot_box_with_check: Path of the root folder that contains the web files.
    RequestsTimeoutSec int :ballot_box_with_check: :ballot_box_with_check: Timeout in seconds to waiting the next data reception of requests.
    NotFoundURL str or None :ballot_box_with_check: :ballot_box_with_check: URL used to redirects requests not found.
    AllowAllOrigins bool :ballot_box_with_check: :ballot_box_with_check: Indicates that all resource origins of requests are allowed.
    CORSAllowAll bool :ballot_box_with_check: :ballot_box_with_check: Allows all CORS values for the pre-flight requests (OPTIONS).
    OnLogging callback or None :ballot_box_with_check: :ballot_box_with_check: Callback function when the server logs information.

    > Definition of the above callback functions:

    def OnLogging(microWebSrv2, msg, msgType)
    # <microwebsrv2> is of type MicroWebSrv2
    # <msg> is of type str
    # <msgtype> can take following values:
    #    - MicroWebSrv2.DEBUG
    #    - MicroWebSrv2.INFO
    #    - MicroWebSrv2.WARNING
    #    - MicroWebSrv2.ERROR

- ## Web Routes

Web routes allow you to define conditional access paths to
specific resources and react to corresponding http requests.  
They also provide the possibility of using freer
conditions that can be retrieved as input elements.

In microWebSrv2, a web route is composed by a processing handler, a requested method, a requested path and an optional name. The requested path can also consist of variable parts that can be retrieved as arguments.

Finally, during an http request, if the method and path match to a route, the processing handler is called with the expected arguments.


  • Route Processing

    A route processing is an handler function decorated by the setting of the route.
    This setting uses the @WebRoute decorator whose definition is as follows:

    @WebRoute(method, routePath, name=None)
    # <method> is the http requested method and must be a not empty string.
    # <routepath> is the http requested path and must be a not empty string.
    # <name> is an optional route name and must be a string or None.

    The handler function definition is as follows:

    @WebRoute(...)
    def RequestHandler(microWebSrv2, request)
    # <microwebsrv2> is of type MicroWebSrv2
    # <request> is of type HttpRequest

    The method argument can be a string but also one of the following constants:
    GET, HEAD, POST, PUT, DELETE, OPTIONS, PATCH

    The routePath argument must always starts by / and specifies the relative URL of the route.

    > Note that a route processing handler is global and can be called by any instance of MicroWebSrv2 class.

    :cyclone: Example of processing handlers:

    @WebRoute(GET, '/my-resource')
    def RequestHandler1(microWebSrv2, request) :
        pass
    @WebRoute(POST, '/test/virtual-page.html', 'myTestRoute')
    def RequestHandler2(microWebSrv2, request) :
        pass
    @WebRoute(OPTIONS, '/')
    def RequestHandler3(microWebSrv2, request) :
        pass

  • Route Arguments

    It is possible to include route arguments that can be retrieved as input elements.
    These arguments are directly defined in the requested path by naming and framing them with `````` as follows:

    @WebRoute(GET, '/users/<id>/profile/<property>')

    In this web route, two arguments are defined: id and property. Thus, the route is variable and corresponds to the requested path from which any argument can be used.

    '/users/123/profile/firstname'

    So, the handler function definition is extended as follows:

    @WebRoute(...)
    def RequestHandler(microWebSrv2, request, args)
    # <microwebsrv2> is of type MicroWebSrv2
    # <request> is of type HttpRequest
    # <args> is a dictionary of route arguments

    Now, args can be used like args['id'] or args['property']. Note that values can be strings but also integers directly.


  • Route Methods

    :arrow_forward: RegisterRoute(...)

    def RegisterRoute(handler, method, routePath, name=None)
    # Registers a global web route directly, without decorator usage.
    #   - No return value.
    #   - <handler> is the route processing handler and must be a function (see above).
    #   - <method> is the http requested method and must be a not empty string.
    #   - <routepath> is the http requested path and must be a not empty string.
    #   - <name> is an optional route name and must be a string or None.
    # An exception can be raised if arguments are not correct.

    :arrow_forward: ResolveRoute(...)

    def ResolveRoute(method, path)
    # Resolves a web route using a method and a path.
    #   - Returns a RouteResult class if no error occurred and route was found, returns None otherwise.
    #   - <method> is an http method and must be of string type.
    #   - <path> is an http relative path and must be of string type.

    The RouteResult class exposes the following properties:

    Name Type
    Handler processing handler
    Method string
    RoutePath string
    Name string or None
    Args dictionary

    :arrow_forward: PathFromRoute(...)

    def PathFromRoute(routeName, routeArgs={ })
    # Constructs the relative path from the route name and route arguments.
    #   - Returns a string that is the relative path.
    #   - <routename> is the name of the web route and must be a not empty string.
    #   - <routeargs> is a dictionary of needed argument names and values.
    # An exception can be raised if arguments are not correct or route was not found.

- ## HttpRequest Class

HttpRequest class represents a received http request by the web server.  
It can be obtained in web route handlers or in modules.  
It also allows you to process the response.


  • HttpRequest instance methods

    :arrow_forward: httpRequest.GetPostedURLEncodedForm(...)

    def GetPostedURLEncodedForm(self)
    # Obtains name/value pairs from an URL encoded form.
    # The http request must have an URL encoded form content.
    #   - Returns a dictionary of name/value pairs (string for both).

    :arrow_forward: httpRequest.GetPostedJSONObject(...)

    def GetPostedJSONObject(self)
    # Obtains the object posted in JSON format.
    # The http request must have a JSON content.
    #   - Returns any type of object or None.

    :arrow_forward: httpRequest.GetHeader(...)

    def GetHeader(self, name)
    # Obtains the value of an http request header.
    #   - Returns always a string value.
    #   - <name> must be a not empty string.
    # An exception can be raised if <name> is not correct.

    :arrow_forward: httpRequest.CheckBasicAuth(...)

    def CheckBasicAuth(self, username, password)
    # Checks if the http request is authenticated with the "Basic" method.
    #   - Returns True if the authentication is correct, returns False otherwise.
    #   - <username> must be a string.
    #   - <password> must be a string.
    # An exception can be raised if arguments are not correct.

    :arrow_forward: httpRequest.CheckBearerAuth(...)

    def CheckBearerAuth(self, token)
    # Checks if the http request is authenticated with the "Bearer" method.
    #   - Returns True if authentication is correct, returns False otherwise.
    #   - <token> is the session token and must be a string.
    # An exception can be raised if <token> is not correct.

  • HttpRequest properties

    Name Type Get Set Description
    UserAddress tuple :ballot_box_with_check: - User remote address of the http connection such as a tuple of (str_ip_addr, int_port).
    IsSSL bool :ballot_box_with_check: - Indicates that the http connection is secured by SSL/TLS security layer with certificate.
    HttpVer str :ballot_box_with_check: - Version of the client protocol of the http connection.
    Method str :ballot_box_with_check: - Name of the method transmitted with this request.
    Path str :ballot_box_with_check: - Path of the resource transmitted with this request.
    QueryString str :ballot_box_with_check: - Full query string transmitted with this request.
    QueryParams dict :ballot_box_with_check: - Parameters of the query string transmitted with this request.
    Host str :ballot_box_with_check: - Hostname transmitted with this request.
    Accept list :ballot_box_with_check: - List of possible content types expected in response to this request.
    AcceptEncodings list :ballot_box_with_check: - List of possible encodings expected in response to this request.
    AcceptLanguages list :ballot_box_with_check: - *List of possible languages expected in response to this request.
    Cookies list :ballot_box_with_check: - List of cookies transmitted with this request.
    CacheControl str :ballot_box_with_check: - Control of cache transmitted with this request.
    Referer str :ballot_box_with_check: - Referer address transmitted with this request.
    ContentType str :ballot_box_with_check: - Type of the content included in this request.
    ContentLength int :ballot_box_with_check: - Length of the content included in this request.
    UserAgent str :ballot_box_with_check: - Name of the client agent transmitted with this request.
    Authorization str :ballot_box_with_check: - Authorization string transmitted with this request.
    Origin str :ballot_box_with_check: - Address of the origin transmitted with this request.
    IsKeepAlive bool :ballot_box_with_check: - Indicates that the http connection can be keep alive.
    IsUpgrade bool :ballot_box_with_check: - Indicates that the http connection must be upgraded.
    Upgrade str :ballot_box_with_check: - Upgrade string transmitted with this request.
    Content memoryview or None :ballot_box_with_check: - Raw data of the content included in this request.
    Response HttpResponse :ballot_box_with_check: - Http response related to this connection.
    XAsyncTCPClient XAsyncTCPClient :ballot_box_with_check: - Asynchronous TCP connection from the XAsyncSockets library.

- ## HttpResponse Class

HttpResponse class is used to manage the reponse of an http request.  
It can be obtained by the ```Response``` property of an instantiated HttpRequest.   


  • HttpResponse instance methods

    :arrow_forward: httpResponse.SetHeader(...)

    def SetHeader(self, name, value)
    # Set a header to the http response.
    #   - No return value.
    #   - <name> must be a not empty string.
    #   - <value> may be anything but cannot be None.
    # An exception can be raised if arguments are not correct.

    :arrow_forward: httpResponse.SwitchingProtocols(...)

    def SwitchingProtocols(self, upgrade)
    # Sends a special http response to upgrade the connection.
    #   - No return value.
    #   - <upgrade> must be a not empty string.
    # An exception can be raised if <upgrade> is not correct.

    :arrow_forward: httpResponse.ReturnStream(...)

    def ReturnStream(self, code, stream)
    # Sends a stream content to the http response.
    #   - No return value.
    #   - <code> is the http status code and must be a positive integer.
    #   - <stream> must be a readable buffer protocol object.
    # An exception can be raised if arguments are not correct.

    :arrow_forward: httpResponse.Return(...)

    def Return(self, code, content=None)
    # Sends an http response with or without content.
    #   - No return value.
    #   - <code> is the http status code and must be a positive integer.
    #   - <content> must be a string or in bytes or convertible into bytes or None.
    # An exception can be raised if arguments are not correct.

    :arrow_forward: httpResponse.ReturnJSON(...)

    def ReturnJSON(self, code, obj)
    # Sends an http response with a JSON content.
    #   - No return value.
    #   - <code> is the http status code and must be a positive integer.
    #   - <obj> can be anything and will be serialized (stringify process).
    # An exception can be raised if arguments are not correct.

    :arrow_forward: httpResponse.ReturnOk(...)

    def ReturnOk(self, content=None)
    # Sends a success http response with or without content.
    #   - No return value.
    #   - <content> must be a string or in bytes or convertible into bytes or None.
    # An exception can be raised if <content> is not correct.

    :arrow_forward: httpResponse.ReturnOkJSON(...)

    def ReturnOkJSON(self, obj)
    # Sends a success http response with a JSON content.
    #   - No return value.
    #   - <obj> can be anything and will be serialized (stringify process).
    # An exception can be raised if <obj> is not correct.

    :arrow_forward: httpResponse.ReturnFile(...)

    def ReturnFile(self, filename, attachmentName=None)
    # Sends a file to the http response.
    #   - No return value.
    #   - <filename> is the physical path of the file and must be a not empty string.
    #   - <attachmentname> can be the name of the file to save, in string, or None.
    #     If None, the user will see it "on the fly" in his browser, he will can save it otherwise.
    # An exception can be raised if arguments are not correct.

    :arrow_forward: httpResponse.ReturnNotModified(...)

    def ReturnNotModified(self)
    # Sends a not modified http response.
    # Used in resources caching context.
    #   - No return value.

    :arrow_forward: httpResponse.ReturnRedirect(...)

    def ReturnRedirect(self, location)
    # Sends a temporary redirect http response.
    # Used to move the user to a new url.
    #   - No return value.
    #   - <location> is the relative or absolute URL and must be a not empty string.
    # An exception can be raised if <location> is not correct.

    :arrow_forward: httpResponse.ReturnBadRequest(...)

    def ReturnBadRequest(self)
    # Sends a bad request http response.
    # Used for user request error.
    #   - No return value.
    

    :arrow_forward: httpResponse.ReturnUnauthorized(...)

    def ReturnUnauthorized(self, typeName, realm=None)
    # Sends an unauthorized http response.
    # Used if the user needs to authenticate.
    #   - No return value.
    #   - <typename> is the name of required authentication and must be a not empty string.
    #   - <realm> is a name for the protected resource and can be a string or None.
    # An exception can be raised if arguments are not correct.

    :arrow_forward: httpResponse.ReturnForbidden(...)

    def ReturnForbidden(self)
    # Sends a forbidden http response.
    # Used to indicate a denied access.
    #   - No return value.
    

    :arrow_forward: httpResponse.ReturnNotFound(...)

    def ReturnNotFound(self)
    # Sends a not found http response.
    # Used to indicate that the resource does not exist.
    #   - No return value.
    

    :arrow_forward: httpResponse.ReturnMethodNotAllowed(...)

    def ReturnMethodNotAllowed(self)
    # Sends a method not allowed http response.
    # Used if the method is not supported for resource.
    #   - No return value.
    

    :arrow_forward: httpResponse.ReturnEntityTooLarge(...)

    def ReturnEntityTooLarge(self)
    # Sends an entity too large http response.
    # Used for an excessive content size.
    #   - No return value.
    

    :arrow_forward: httpResponse.ReturnInternalServerError(...)

    def ReturnInternalServerError(self)
    # Sends an internal server error http response.
    # Used if an error has occurred.
    #   - No return value.
    

    :arrow_forward: httpResponse.ReturnNotImplemented(...)

    def ReturnNotImplemented(self)
    # Sends a not implemented http response.
    # Used in case of a non-existent process of the resource.
    #   - No return value.
    

    :arrow_forward: httpResponse.ReturnServiceUnavailable(...)

    def ReturnServiceUnavailable(self)
    # Sends a service unavailable http response.
    # Used if it is currently impossible to process the request.
    #   - No return value.
    

    :arrow_forward: httpResponse.ReturnBasicAuthRequired(...)

    def ReturnBasicAuthRequired(self)
    # Sends an http response to indicate that "Basic" authentication is required.
    #   - No return value.
    

    :arrow_forward: httpResponse.ReturnBearerAuthRequired(...)

    def ReturnBearerAuthRequired(self)
    # Sends an http response to indicate that "Bearer" authentication is required.
    #   - No return value.
    

  • HttpResponse properties

    Name Type Get Set Description
    Request HttpRequest :ballot_box_with_check: - Http request related to this response.
    UserAddress tuple :ballot_box_with_check: - User remote address of the http connection such as a tuple of (str_ip_addr, int_port).
    IsSSL bool :ballot_box_with_check: - Indicates that the http connection is secured by SSL/TLS security layer with certificate.
    AllowCaching bool :ballot_box_with_check: :ballot_box_with_check: Indicates to the user the possible caching of this response.
    AccessControlAllowOrigin str or None :ballot_box_with_check: :ballot_box_with_check: Indicates to the user the allowed resource origin.
    ContentType str or None :ballot_box_with_check: :ballot_box_with_check: Type of the content of this response.
    ContentCharset str or None :ballot_box_with_check: :ballot_box_with_check: Encoding charset used for the content of this response.
    ContentLength int :ballot_box_with_check: :ballot_box_with_check: Length of the content of this response.
    HeadersSent bool :ballot_box_with_check: - Indicates that response http headers was already sent.
    OnSent callback or None :ballot_box_with_check: :ballot_box_with_check: Callback function when response is fully sent.

    > Definition of the above callback functions:

    def OnSent(microWebSrv2, response)
    # <microwebsrv2> is of type MicroWebSrv2
    # <response> is of type HttpResponse

- ## Additional modules

**microWebSrv2** supports additional modules that can be called during the
processing of a web request and can then decide whether or not to intercept it.  
Modules can simply analyze http requests or responding to them so that
they cannot continue their normal pipe-line processing.

A module file must be placed in the "/mods" directory of the package and must define a class of the same name.
In addition, this class must implement the OnRequest(...) method that will be called at each http request.

:cyclone: Example of a module named "TestMod.py":

class TestMod :

    def OnRequest(self, microWebSrv2, request) :
        print('TestMod: Request received from %s:%s' % request.UserAddress)

  • WebSockets Module

    WebSockets module must be loaded first by microWebSrv2 to process WebSocket connections.
    These are fully managed asynchronous I/Os and really many connections can be processed.
    After module loaded, do not forget to assign the callback OnWebSocketAccepted. If you need to select and process a sub-protocol, you must assign the callback OnWebSocketProtocol.

    from MicroWebSrv2 import *
    
    WS_CHAT_SUB_PROTOCOL = 'myGreatChat-v1'
    
    def OnWebSocketProtocol(microWebSrv2, protocols) :
        if WS_CHAT_SUB_PROTOCOL in protocols :
            return WS_CHAT_SUB_PROTOCOL
    
    def OnWebSocketAccepted(microWebSrv2, webSocket) :
        print('New WebSocket (myGreatChat proto) accepted from %s:%s.' % webSocket.Request.UserAddress)
    
    wsMod = MicroWebSrv2.LoadModule('WebSockets')
    wsMod.OnWebSocketProtocol = OnWebSocketProtocol
    wsMod.OnWebSocketAccepted = OnWebSocketAccepted

    • WebSockets module properties

      Name Type Get Set Description
      OnWebSocketProtocol callback or None :ballot_box_with_check: :ballot_box_with_check: Callback function when a new WebSocket connection negociates a sub-protocol.
      OnWebSocketAccepted callback or None :ballot_box_with_check: :ballot_box_with_check: Callback function when a new WebSocket connection is accepted.

      > Definition of the above callback functions:

      def OnWebSocketProtocol(microWebSrv2, protocols)
      # <microwebsrv2> is of type MicroWebSrv2
      # <protocols> is a string list of proposed protocols
      # RETURN: If you select a protocol, you must return it (the same as in the list)

      def OnWebSocketAccepted(microWebSrv2, webSocket)
      # <microwebsrv2> is of type MicroWebSrv2
      # <websocket> is of type WebSocket

    • WebSocket Class

      WebSocket class is automatically instantiated by WebSockets module.
      A WebSocket can be obtained when a new connection is accepted in the callback OnWebSocketAccepted. It is also important to assign WebSocket callbacks in order to receive the various events.


      • WebSocket instance methods

        :arrow_forward: webSocket.SendTextMessage(...)

        def SendTextMessage(self, msg)
        # Sends a text message through the WebSocket.
        #   - Returns True or False.
        #   - <msg> must be a not empty string.
        # An exception can be raised if <msg> is not correct.

        :arrow_forward: webSocket.SendBinaryMessage(...)

        def SendBinaryMessage(self, msg)
        # Sends a binary message through the WebSocket.
        #   - Returns True or False.
        #   - <msg> must be in bytes or convertible into bytes and not empty.
        # An exception can be raised if <msg> is not correct.

        :arrow_forward: webSocket.Close(...)

        def Close(self)
        # Closes the WebSocket.
        #   - No return value.

      • WebSocket properties

        Name Type Get Set Description
        Request HttpRequest :ballot_box_with_check: - Http request related to this connection.
        IsClosed bool :ballot_box_with_check: - Indicates that connection is closed.
        WaitFrameTimeoutSec int :ballot_box_with_check: :ballot_box_with_check: Timeout in seconds to waiting next frame.
        MaxRecvMessageLength int or None :ballot_box_with_check: :ballot_box_with_check: Maximum length of messages to receive.
        OnTextMessage callback or None :ballot_box_with_check: :ballot_box_with_check: Callback function to receive text messages.
        OnBinaryMessage callback or None :ballot_box_with_check: :ballot_box_with_check: Callback function to receive binary messages.
        OnClosed callback or None :ballot_box_with_check: :ballot_box_with_check: Callback function when connection is closed.

        > Definition of the above callback functions:

        def OnTextMessage(webSocket, msg)
        # <websocket> is of type WebSocket
        # <msg> is of type str

        def OnBinaryMessage(webSocket, msg)
        # <websocket> is of type WebSocket
        # <msg> is of type memoryview

        def OnClosed(webSocket)
        # <websocket> is of type WebSocket

  • PyhtmlTemplate Module

    PyhtmlTemplate module must be loaded first by microWebSrv2 to process .pyhtml pages.
    With it, you will be able to render HTML pages directly integrating Python/MicroPython language.

    from MicroWebSrv2 import *
    
    pyhtmlTemplateMod = MicroWebSrv2.LoadModule('PyhtmlTemplate')
    pyhtmlTemplateMod.ShowDebug = True

    In the pages .pyhtml, you must use the following instructions:

    Instruction Code schema
    PY {{ py }} Python code {{ end }}
    IF {{ if Python condition }} html bloc {{ end }}
    ELIF {{ elif Python condition }} html bloc {{ end }}
    ELSE {{ else }} html bloc {{ end }}
    FOR {{ for identifier in Python iterator }} html bloc {{ end }}
    Expression {{ Python expression }}

    :cyclone: See the test.pyhtml page for the example:

    Pyhtml Code

    Pyhtml Page


    • PyhtmlTemplate module instance methods

      :arrow_forward: pyhtmlTemplateMod.SetGlobalVar(...)

      def SetGlobalVar(self, globalVarName, globalVar)
      # Defines a global variable accessible by all pyhtml pages.
      #   - No return value.
      #   - <globalvarname> must be a not empty string.
      #   - <globalvar> must be an object or None.
      # An exception can be raised if <globalvarname> is not correct.

      :arrow_forward: pyhtmlTemplateMod.GetGlobalVar(...)

      def GetGlobalVar(self, globalVarName)
      # Retrieves a global variable accessible by all pyhtml pages.
      #   - Returns an object or None.
      #   - <globalvarname> must be a not empty string.
      # An exception can be raised if <globalvarname> is not correct.

    • PyhtmlTemplate module properties

      Name Type Get Set Description
      ShowDebug bool :ballot_box_with_check: :ballot_box_with_check: Enables debugging on web pages.

:wink:  Author

Jean-Christophe Bos (:fr:) - GitHub: @jczic - Email: [email protected] - Web: www.hc2.fr


:eightpointedblack_star:  License



We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.