vesta-web 1.1.0__py3-none-any.whl

vesta/http/baseServer.py

@@ -0,0 +1,257 @@
+import fastwsgi
+import inspect
+
+import os
+import time
+import json
+import hashlib
+import base64
+
+import re
+import urllib
+
+#requests modules
+import multipart as mp
+from io import BytesIO
+
+from configparser import ConfigParser
+
+from vesta.http import response
+from vesta.http import error
+from vesta.http import redirect
+from vesta.db import db_service as db
+Response = response.Response
+HTTPRedirect = redirect.HTTPRedirect
+HTTPError = error.HTTPError
+
+RE_URL = re.compile(r"[\&]")
+RE_PARAM = re.compile(r"[\=]")
+
+routes = {}
+
+from colorama import Fore, Style
+from colorama import init as colorama_init
+colorama_init()
+
+class BaseServer:
+    features = {}
+
+    def __init__(self, path, configFile, noStart=False):
+        print(Fore.GREEN,"[INFO] starting Vesta server...")
+        self.path = path
+
+        self.importConf(configFile)
+
+        if noStart:
+            return
+
+        self.start()
+
+    #----------------------------HTTP SERVER------------------------------------
+    def expose(func):
+        def wrapper(self, *args, **kwargs):
+
+            res = func(self, *args, **kwargs)
+            # print("[DEBUG] res : ", res)
+
+            self.response.ok()
+            if res:
+
+                return res.encode()
+            else:
+                return "".encode()
+
+        name = func.__name__
+        if func.__name__ == "index":
+            name = "/"
+        elif func.__name__ == "default":
+            name = "default"
+        else:
+            name = "/" + func.__name__
+
+        routes[name] = {"params": inspect.signature(func).parameters, "target": wrapper}
+        return wrapper
+
+    def saveFile(self, content, name="",ext=None, category=None):
+        content = content.split(",")
+        extension = content[0].split("/")[1].split(";")[0]
+        content = base64.b64decode(content[1])
+
+        if not name :
+            hash_object = hashlib.sha256(content)
+            hex_dig = hash_object.hexdigest()
+
+            name = hex_dig
+
+        prefix = self.path + "/static/attachments/"
+        if category:
+            name = category + "/"  + name
+        if ext :
+            name = name + "." + ext
+
+        with open(prefix+name, 'wb') as f:
+            f.write(content)
+        return name
+
+    def parseCookies(self, cookieStr):
+        if not cookieStr:
+            return
+        cookies = {}
+        for cookie in cookieStr.split(';'):
+            key, value = cookie.split('=')
+            cookies[key.strip()] = value
+        return cookies
+
+
+    def parseRequest(self,environ):
+        self.response.cookies = self.parseCookies(environ.get('HTTP_COOKIE'))
+
+        if environ.get('CONTENT_TYPE'):
+            content_type = environ.get('CONTENT_TYPE').strip().split(";")
+        else:
+            content_type = ["text/html"]
+
+        args = {}
+        if environ.get('QUERY_STRING'):
+            query = re.split(RE_URL, environ['QUERY_STRING'])
+            for i in range(0, len(query)):
+                query[i] = re.split(RE_PARAM, query[i])
+                args[query[i][0]] = urllib.parse.unquote(query[i][1])
+        if content_type[0] == "multipart/form-data":
+            length = int(environ.get('CONTENT_LENGTH'))
+            body = environ['wsgi.input'].read(length)
+            sep = content_type[1].split("=")[1]
+            body = mp.MultipartParser(BytesIO(body), sep.encode('utf-8'))
+            for part in body.parts():
+                args[part.name] = part.value
+        if content_type[0] == "application/json":
+            length = int(environ.get('CONTENT_LENGTH'))
+            body = environ['wsgi.input'].read(length)
+            body = json.loads(body)
+            for key in body:
+                args[key] = body[key]
+
+        return args
+
+
+    def tryDefault(self, environ, target):
+        print(Fore.WHITE,"[INFO] Vesta - using default route")
+
+        args = self.parseRequest(environ)
+        args["target"] = target
+        try:
+            return routes["default"]["target"](self, **args)
+        except (HTTPError, HTTPRedirect):
+            return self.response.encode()
+        except Exception as e:
+            return self.handleUnexpected(e)
+
+
+    def onrequest(self, environ, start_response):
+        self.response = Response(start_response=start_response)
+        print(Fore.WHITE,"[INFO] Vesta - request received :'", str(environ['PATH_INFO']) + "'" + " with "+ str(environ.get('QUERY_STRING')))
+        target = environ['PATH_INFO']
+
+        if routes.get(target):
+            args = self.parseRequest(environ)
+
+            try:
+                if len(args) == 0:
+                    return routes[target]["target"](self)
+                return routes[target]["target"](self, **args)
+            except (HTTPError, HTTPRedirect):
+                return self.response.encode()
+            except Exception as e:
+               return self.handleUnexpected(e)
+        else:
+            if routes.get("default"):
+                return self.tryDefault(environ, target)
+            self.response.code = 404
+            self.response.ok()
+            return self.response.encode()
+
+    def handleUnexpected(self, e):
+        print(Fore.RED,"[ERROR] Vesta - UNEXPECTED ERROR :", e)
+        self.response.code = 500
+        self.response.ok()
+        self.response.content = str(e)
+        tb = e.__traceback__
+        while tb is not None:
+            frame = tb.tb_frame
+            lineno = tb.tb_lineno
+            filename = frame.f_code.co_filename
+            funcname = frame.f_code.co_name
+            print(f'  File "{filename}", line {lineno}, in {funcname}')
+            if self.features.get("debug"):
+                self.response.content += f'  File "{filename}", line {lineno}, in {funcname}'
+            tb = tb.tb_next
+        return self.response.encode()
+
+    def onStart(self):
+        pass
+
+    #--------------------------GENERAL USE METHODS------------------------------
+
+    def importConf(self, configFile):
+        self.config = ConfigParser()
+        try:
+            self.config.read(self.path + configFile)
+            print(Fore.GREEN,"[INFO] Vesta - config at " + self.path + configFile + " loaded")
+        except Exception:
+            print(Fore.RED,"[ERROR] Vesta - Please create a config file")
+
+    def start(self):
+        self.fileCache = {}
+
+        if self.features.get("errors"):
+            for code, page in self.features["errors"].items():
+                Response.ERROR_PAGES[code] = self.path + page
+
+        if self.features.get("orm") == True:
+            self.db = db.DB(user=self.config.get('DB', 'DB_USER'), password=self.config.get('DB', 'DB_PASSWORD'),
+                            host=self.config.get('DB', 'DB_HOST'), port=int(self.config.get('DB', 'DB_PORT')),
+                            db=self.config.get('DB', 'DB_NAME'))
+
+
+        self.onStart()
+
+        fastwsgi.server.nowait = 1
+        fastwsgi.server.hook_sigint = 1
+
+        print(Fore.GREEN,"[INFO] Vesta - server running on PID:", os.getpid())
+        fastwsgi.server.init(app=self.onrequest, host=self.config.get('server', 'IP'),
+                             port=int(self.config.get('server', 'PORT')))
+        while True:
+            code = fastwsgi.server.run()
+            if code != 0:
+                break
+            time.sleep(0)
+        self.close()
+
+    def close(self):
+        print(Fore.GREEN,"[INFO] SIGTERM/SIGINT received")
+        fastwsgi.server.close()
+        print(Fore.GREEN,"[INFO] SERVER STOPPED")
+        exit()
+
+    def file(self, path, responseFile=True):
+        if responseFile:
+            self.response.type = "html"
+            self.response.headers = [('Content-Type', 'text/html')]
+        file = self.fileCache.get(path)
+        if file:
+            return file
+        else:
+            file = open(path)
+            content = file.read()
+            file.close()
+            self.fileCache[path] = content
+            return content
+
+    def start_ORM(self):
+        if self.features.get("orm") == True:
+            self.db = db.DB(user=self.config.get('DB', 'DB_USER'), password=self.config.get('DB', 'DB_PASSWORD'),
+                            host=self.config.get('DB', 'DB_HOST'), port=int(self.config.get('DB', 'DB_PORT')),
+                            db=self.config.get('DB', 'DB_NAME'))
+        else:
+            raise Exception("ORM not enabled")

vesta/http/error.py

@@ -0,0 +1,5 @@
+class HTTPError(Exception):
+    def __init__(self, response, code=500, message="Unexpected"):
+        response.code = code
+        response.content = message
+        response.ok()

vesta/http/redirect.py

@@ -0,0 +1,5 @@
+class HTTPRedirect(Exception):
+    def __init__(self, response, target):
+        response.code = 302
+        response.headers.append(('Location', target))
+        response.ok()

vesta/http/response.py

@@ -0,0 +1,85 @@
+import datetime
+
+class Response:
+    CODES = {200: "200 OK", 400: "400 Bad Request", 403: "403 Forbidden", 404: "404 Not Found", 500: "500 Server Error", 302: "302 Redirect"}
+    ERROR_PAGES = {}
+
+    def __init__(self, start_response, code=200, type="html"):
+        self.cookies = {}
+        self.type = type
+        self.headers = [('Content-Type', 'text/' + type),('Cache-Control', 'no-cache'), ('Server', 'mag v1 Harpie')]
+        self.code = code
+        self.start_response = start_response
+        self.content = ""
+
+    def ok(self):
+        if self.code != 200 and self.code != 302:
+            if self.code in self.ERROR_PAGES.keys():
+                self.type = "html"
+                self.headers = [('Content-Type', 'text/html')]
+                file = open(self.ERROR_PAGES[self.code])
+                self.content = file.read()
+                file.close()
+            else:
+                self.type = "plain"
+                self.headers = [('Content-Type', 'text/plain')]
+        self.start_response(self.CODES.get(self.code, "500 UNEXPECTED"), self.headers)
+
+    def encode(self):
+        # print("[INFO] encoding response : ", self.content)
+
+        if self.type == "plain":
+            return (self.CODES[self.code] + " " + self.content).encode()
+        return str(self.content).encode()
+
+    def set_cookie(self, name, value, exp=None, samesite=None, secure=False, httponly=False):
+        """Set a response cookie for the client.
+        name
+            the name of the cookie.
+
+        exp
+            the expiration timeout for the cookie. If 0 or other boolean
+            False, no 'expires' param will be set, and the cookie will be a
+            "session cookie" which expires when the browser is closed.
+
+        samesite
+            The 'SameSite' attribute of the cookie. If None (the default)
+            the cookie 'samesite' value will not be set. If 'Strict' or
+            'Lax', the cookie 'samesite' value will be set to the given value.
+
+        secure
+            if False (the default) the cookie 'secure' value will not
+            be set. If True, the cookie 'secure' value will be set (to 1).
+
+        httponly
+            If False (the default) the cookie 'httponly' value will not be set.
+            If True, the cookie 'httponly' value will be set (to 1).
+
+        """
+
+        # Calculate expiration time
+        expires = None
+        if exp:
+            if exp['unit'] == "days":
+                expires = datetime.datetime.now() + datetime.timedelta(days=exp['value'])
+            elif exp['unit'] == "minutes":
+                expires = datetime.datetime.now() + datetime.timedelta(minutes=exp['value'])
+            expires = expires.strftime("%a, %d-%b-%Y %H:%M:%S GMT")
+
+        # Construct cookie string
+        cookie_parts = [f"{name}={value}"]
+        if expires:
+            cookie_parts.append(f"Expires={expires}")
+        if samesite:
+            cookie_parts.append(f"SameSite={samesite}")
+        if secure:
+            cookie_parts.append("Secure")
+        if httponly:
+            cookie_parts.append("HttpOnly")
+        cookie_string = "; ".join(cookie_parts)
+
+        # Add cookie to headers
+        self.headers.append(('Set-Cookie', cookie_string))
+
+    def del_cookie(self, name):
+        self.set_cookie(name, "", exp={"value": 0, "unit": "days"})

vesta/mailing/mailing_service.py

@@ -0,0 +1,126 @@
+import smtplib
+from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
+import email.utils
+import dkim
+
+
+class Mailing:
+    def __init__(self, host, port, address, password, serviceName, path):
+        try:
+            self.name = serviceName
+            self.host = host
+            self.port = port
+            self.password = password
+            self.smtp = smtplib.SMTP(host, port)
+            self.smtp.ehlo()  # send the extended hello to our server
+            self.smtp.starttls()
+            self.address = address
+            self.smtp.login(address, password)
+            self.templates = {}
+            self.path = path
+            with open(self.path + "/mailing/dkim.txt") as fh:
+                self.private = fh.read()
+            print("[Vesta - mails] server connected")
+        except smtplib.SMTPException as e:
+            print(f"Error connecting to mailing server : {e}")
+            self.smtp.quit()
+
+    def restart(self):
+        self.smtp = smtplib.SMTP(self.host, self.port)
+        self.smtp.ehlo()  # send the extended hello to our server
+        self.smtp.starttls()
+        self.smtp.login(self.address, self.password)
+        print("[Vesta - mails] server reconnected")
+
+    def is_connected(conn):
+        try:
+            status = conn.noop()[0]
+        except:  # smtplib.SMTPServerDisconnected
+            status = -1
+        return True if status == 250 else False
+
+    def sendMail(self, content):
+        if not self.is_connected():
+            self.restart()
+        try:
+            self.smtp.send_message(content)
+            print("[Vesta - mails] mail sent")
+        except smtplib.SMTPException as e:
+            print(f"Error sending a mail : {e}")
+
+    def sendTemplate(self,template,target,subject,text,values):
+        try:
+            self.templates[template]
+        except:
+            f = open(self.path + "/mailing/" + template, "r")
+            self.templates[template] = f.read()
+            f.close()
+
+        mail_confirmation = MIMEMultipart('alternative')
+        mail_confirmation['Subject'] = subject
+        mail_confirmation['From'] = self.name + " <" + self.address + ">"
+        mail_confirmation['Message-ID'] = email.utils.make_msgid(domain='carbonlab.dev')
+        mail_confirmation['Date'] = email.utils.formatdate()
+        part1 = MIMEText(text, 'plain')
+        part2 = MIMEText(self.templates[template].format(values), 'html')
+        mail_confirmation.attach(part1)
+        mail_confirmation.attach(part2)
+        mail_confirmation['To'] = target  # ATTENTION CE N'EST PAS UNE COPIE CACHEE
+        self.signMail(mail_confirmation)
+        self.sendMail(mail_confirmation)
+
+    def signMail(self, mail):
+        headers = ["To", "From", "Subject"]
+        sig = dkim.sign(
+            message=mail.as_bytes(),
+            selector="1686741263.carbonlab".encode(),
+            domain="carbonlab.dev".encode(),
+            privkey=self.private.encode(),
+            include_headers=headers, )
+        mail["DKIM-Signature"] = sig[len("DKIM-Signature: "):].decode()
+
+    def sendConfirmation(self, target, OTP):
+        try:
+            self.template_confirmation
+        except:
+            f = open(self.path + "/mailing/mailVerif.html", "r")
+            self.template_confirmation = f.read()
+            f.close()
+
+        mail_confirmation = MIMEMultipart('alternative')
+        mail_confirmation['Subject'] = "🌱 Confirmez votre adresse ! 📨"
+        mail_confirmation['From'] = self.name + " <" + self.address + ">"
+        mail_confirmation['Message-ID'] = email.utils.make_msgid(domain='carbonlab.dev')
+        mail_confirmation['Date'] = email.utils.formatdate()
+        text = "Confirm your " + self.name + " account : " + OTP
+        part1 = MIMEText(text, 'plain')
+        part2 = MIMEText(self.template_confirmation.format(OTP), 'html')
+        mail_confirmation.attach(part1)
+        mail_confirmation.attach(part2)
+        mail_confirmation['To'] = target  # ATTENTION CE N'EST PAS UNE COPIE CACHEE
+        self.signMail(mail_confirmation)
+        self.sendMail(mail_confirmation)
+
+    def sendOrgInvite(self, target, company):
+        try:
+            self.template_org_invitation
+        except:
+            f = open(self.path + "/mailing/mailInvite.html", "r")
+            self.template_org_invitation = f.read()
+            f.close()
+            self.mail_invitation = MIMEMultipart('alternative')
+            self.mail_invitation['Subject'] = "🔔 Rejoignez " + company + " 🔔"
+            self.mail_invitation['From'] = self.name + " <" + self.address + ">"
+
+        self.mail_invitation['Message-ID'] = email.utils.make_msgid(domain='carbonlab.dev')
+        self.mail_invitation['Date'] = email.utils.formatdate()
+        text = "Inscrivez vous sur " + self.name + " pour rejoindre " + company
+        part1 = MIMEText(text, 'plain')
+        part2 = MIMEText(self.template_org_invitation.format(company,company), 'html')
+        self.mail_invitation.attach(part1)
+        self.mail_invitation.attach(part2)
+        self.mail_invitation['To'] = target  # ATTENTION CE N'EST PAS UNE COPIE CACHEE
+        self.signMail(self.mail_invitation)
+
+        self.sendMail(self.mail_invitation)

vesta/scripts/initDB.py

@@ -0,0 +1,52 @@
+from vesta import Server
+from os.path import abspath, dirname
+import sys
+from psycopg import sql
+
+PATH = dirname(abspath(__file__))
+
+
+class DBInitializer(Server):
+    def initUniauth(self):
+        if sys.argv[1].upper() == 'Y':
+            self.uniauth.initUniauth()
+
+    def initDB(self):
+        self.referenceUniauth()
+        self.db.cur.execute(open(self.path + "/db/schema.sql", "r").read())
+        self.db.conn.commit()
+
+    def referenceUniauth(self):
+        self.db.cur.execute("CREATE EXTENSION if not exists postgres_fdw;")
+        self.db.cur.execute(
+            sql.SQL("""
+            CREATE SERVER if not exists uniauth
+            FOREIGN DATA WRAPPER postgres_fdw
+            OPTIONS (host {}, port {}, dbname {});
+            """).format(
+                sql.Literal(self.config.get('UNIAUTH', 'DB_HOST')),
+                sql.Literal(self.config.get('UNIAUTH', 'DB_PORT')),
+                sql.Literal(self.config.get('UNIAUTH', 'DB_NAME'))
+            ))
+
+        self.db.cur.execute(
+            sql.SQL("""
+            CREATE USER MAPPING if not exists FOR CURRENT_USER SERVER uniauth
+            OPTIONS (user '%s', password '%s');
+            """).format(
+                sql.Literal(self.config.get('DB', 'DB_USER')),
+                sql.Literal(self.config.get('DB', 'DB_PASSWORD'))
+            ))
+        self.db.cur.execute(
+            """
+            CREATE FOREIGN TABLE if not exists account (id bigserial NOT NULL)
+            SERVER uniauth
+            OPTIONS (schema_name 'public', table_name 'account');
+            """)
+
+
+
+initializer = DBInitializer(path=PATH[:-3], configFile="/server.ini", noStart=True)
+initializer.initUniauth()
+initializer.initDB()
+print("DB ready")

vesta/scripts/install.py

@@ -0,0 +1,76 @@
+import sys
+from configparser import ConfigParser
+from os.path import abspath, dirname
+import subprocess
+
+PATH = dirname(abspath(__file__))
+
+
+class Installer:
+    def __init__(self, configFile, arg="all"):
+        self.importConf(configFile)
+        self.uniauth = "N"
+        self.name = self.config.get("server", "SERVICE_NAME").replace(" ", "_").upper()
+
+        if arg == "all" or arg == "a":
+            self.installAll()
+        elif arg == "db":
+            self.installDB()
+        elif arg == "uniauth":
+            self.installUniauth()
+        elif arg == "vesta":
+            self.resetVesta()
+        elif arg == "reset":
+            self.resetDB()
+        elif arg == "service":
+            self.installService()
+        elif arg == "cron":
+            self.setupCrons()
+
+    def ex(self, command):
+        subprocess.run(command, shell=True, check=True)
+
+    def installDB(self):
+        print("----DB----")
+        self.ex("sudo -u postgres createdb " + self.config.get("DB", "DB_NAME"))
+        self.ex("sudo -u postgres createuser " + self.config.get("DB", "DB_USER") + " -s --pwprompt ")
+
+    def resetVesta(self):
+        self.ex("pip uninstall vesta")
+        self.ex("pip install git+https://gitlab.com/Louciole/vesta.git/")
+
+    def installUniauth(self):
+        print("----UNIAUTH----")
+        while True:
+            uniauth = input("Do you want to create a uniauth database? (y/n)")
+            if uniauth.upper() == 'Y' or uniauth.upper() == 'N':
+                self.uniauth = uniauth.upper()
+                break
+
+        if self.uniauth == 'Y':
+            self.ex("sudo -u postgres createdb " + self.config.get("UNIAUTH", "DB_NAME"))
+
+    def initDB(self):
+        self.ex("python3 ./db/initDB.py " + self.uniauth)
+
+    def resetDB(self):
+        self.ex("sudo -u postgres dropdb " + self.config.get("DB", "DB_NAME"))
+        self.initDB()
+
+    def installAll(self):
+        self.installNginx()
+        self.installDB()
+        self.installUniauth()
+        self.initDB()
+
+
+
+
+
+
+
+
+if len(sys.argv) > 1:
+    Installer(PATH + "/server.ini", sys.argv[1])
+else:
+    Installer(PATH + "/server.ini")

vesta/scripts/testsRun.py

@@ -0,0 +1,83 @@
+import os
+import sys
+import importlib
+from colorama import Fore, Style, init
+
+def run_file(file_path):
+    """Runs a single Python test file."""
+    # Extract the module name from the file path
+    readable_path = file_path.strip(test_dir)
+
+    # Import the test module
+    try:
+        module_path = os.path.splitext(file_path[2:])[0]
+        module_name = module_path.replace(os.sep, '.')
+        test_module = importlib.import_module(module_name)
+    except ModuleNotFoundError as e:
+        print(f"Failed to import test module '{module_name}': {e}")
+        return False
+
+    # Look for a 'run' function within the module (assuming tests are run from this function)
+    if hasattr(test_module, 'run'):
+        try:
+            result = test_module.run()
+            for res in result:
+                if res[1] == False:
+                    print(Fore.RED +f"FAILED: '{res[0]}' @{readable_path}")
+                    return False
+                else:
+                    print(Fore.GREEN +f"PASSED: '{res[0]}' @{readable_path}")
+                    return True
+        except Exception as e:
+            print(f"Error running test file '{readable_path}': {e}")
+    else:
+        print(f"Test file '{readable_path}' doesn't have a 'run' function.")
+
+    return False
+
+
+def run_folder(folder):
+    """Runs all Python test files in a directory."""
+    counter = (0,0)
+
+    for root, _, files in os.walk(folder):
+        for file in files:
+            if file.endswith('.py'):
+                file_path = os.path.join(root, file)
+                res = run_file(file_path)
+                if res == True:
+                    counter = (counter[0]+1,counter[1]+1)
+                elif res == False:
+                    counter = (counter[0],counter[1]+1)
+
+    return counter
+
+test_dir = "./tests"
+
+if __name__ == "__main__":
+    init()# Initialize colorama
+
+    counter = 0
+    total = 0
+
+    cwd = os.getcwd()
+    if cwd not in sys.path:
+        sys.path.insert(0, cwd)
+
+    for _, dirs, _ in os.walk(test_dir):
+        for folder in dirs:
+            if folder == '__pycache__':
+                continue
+            print("Running folder "+folder)
+            count = run_folder(test_dir+'/'+folder)
+            counter += count[0]
+            total += count[1]
+
+    if counter == total:
+        color = Fore.GREEN
+        exCode = 0
+    else:
+        color = Fore.RED
+        exCode = 1
+    print(color + f"{counter}/{total} tests passed")
+    exit(exCode)