babyweb 0.1.0__py3-none-any.whl

babyweb/__init__.py

@@ -0,0 +1,7 @@
+from .server import run_dez_webserver
+from .util import succeed, succeed_sync, fail, redirect, local, cgi_get, cgi_dump, trysavedresponse, set_pre_close, send_file, send_text, send_xml, send_image, send_pdf
+from .memcache import getmem, setmem, delmem, clearmem, getcache
+from .requesters import fetch, post
+from .response import read_file
+from .controller import respond
+from .version import __version__

babyweb/config.py

@@ -0,0 +1,54 @@
+from fyg import Config, PCache
+
+config = Config({
+	"cache": PCache(".tw"),
+	"encode": False,
+	"memcache": False,
+	"mempad": 0, # 0 = unset (uses dez's default)
+	"webs": {},
+	"log": {
+		"oflist": False,
+		"openfiles": False,
+		"tracemalloc": False,
+		"allow": ["info", "log", "warn", "error"] # access,info,log,warn,error,detail,db,query,kernel
+	},
+	"mail": {
+		"mailer": None,
+		"name": None,
+		"html": True,
+		"gmailer": False,
+		"verbose": False,
+		"scantick": 2
+	},
+	"web": {
+		"domain": "your.web.domain",
+		"host": "0.0.0.0",
+		"port": 8080,
+		"protocol": "http",
+		"xorigin": False,
+		"report": False,
+		"shield": False,
+		"debug": False,
+		"csp": None,
+		"log": None,
+		"errlog": None,
+		"rollz": {},
+		"eflags": [],
+		"blacklist": [],
+		"whitelist": []
+	},
+	"admin": {
+		"contacts": [],
+		"reportees": []
+	},
+	"ssl": {
+		"verify": True,
+		"certfile": None,
+		"keyfile": None,
+		"cacerts": None
+	},
+	"cron": {
+		"catchup": False
+	},
+	"scrambler": "1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ+/=_"
+})

babyweb/controller.py

@@ -0,0 +1,89 @@
+import os, sys, platform
+from dez.network import SocketController, daemon_wrapper
+from .shield import setShield, writeBlacklist
+from .logger import logger_getter
+from .response import Response
+from .daemons import webs
+from .cron import Cron
+from .version import __version__
+from .util import do_respond, localvars
+from .config import config
+
+CTR = None
+
+class Controller(SocketController):
+	def __init__(self, *args, **kwargs):
+		self.logger = logger_getter("Controller")
+		SocketController.__init__(self, *args, **kwargs)
+		self.handlers = {}
+		self.modules = {}
+		self.webs = {}
+		self.blcount = 0
+		self.blchunk = getattr(config.web.shield, "chunk", 5)
+		self.logger.info("babyweb: %s"%(__version__,))
+		self.logger.info("Python: %s"%(sys.version.split(' ')[0],))
+		self.logger.info("System: " + " > ".join([part for part in platform.uname() if part]))
+
+	def _respond(self, resp, *args, **kwargs):
+		if resp == "nothread": # "on start nothread" cron
+			kwargs["noLoad"] = True
+		elif resp: # regular request
+			kwargs["response"] = resp
+			localvars.response = resp
+		else: # regular cron
+			kwargs["noLoad"] = True
+			kwargs["threaded"] = True
+		do_respond(*args, **kwargs)
+
+	def register_handler(self, args, kwargs):
+		self.logger.info("register handler: %s"%(self.curpath,))
+		self.handlers[self.curpath] = lambda resp : self._respond(resp, *args, **kwargs)
+
+	def trigger_handler(self, rule, target, req=None, option=None):
+		self.curpath = rule
+		if rule not in self.handlers:
+			if target in self.modules:
+				self.logger.info("linking module: %s"%(target,))
+				self.handlers[rule] = self.modules[target]
+			else:
+				self.logger.info("importing module: %s"%(target,))
+				__import__(target)
+				self.modules[target] = self.handlers[rule]
+		self.handlers[rule](req and Response(req) or option)
+
+	def blup(self):
+		blen = writeBlacklist()
+		self.logger.warn("saved %s IPs in black.list"%(blen,))
+		if self.blcount != blen:
+			self.blcount = blen
+			if config.web.report and not blen % self.blchunk:
+				from .mail import email_admins
+				email_admins("sketch IPs blacklisted", "sketch count: %s"%(blen,))
+
+	def web(self, name, cfg, daemon, shield):
+		self.webs[name] = self.register_address(cfg.host,
+			cfg.port, dclass=daemon_wrapper(daemon, logger_getter, shield, config.mempad))
+		self.webs[name].controller = self
+
+def getController():
+	global CTR
+	if not CTR:
+		# controller
+		CTR = Controller()
+		shield = setShield(CTR.blup)
+		mempad = config.mempad
+
+		for web in webs:
+			CTR.web(web, config.webs[web], webs[web], shield)
+
+		# cron
+		Cron(CTR, logger_getter)
+
+	return CTR
+
+def dweb(wname="web"):
+	return getController().webs.get(wname)
+
+def respond(*args, **kwargs):
+	getController().register_handler(args, kwargs)
+

babyweb/cron.py

@@ -0,0 +1,115 @@
+import time, os
+from datetime import datetime, timedelta
+from fyg.util import read, write
+from rel import timeout
+from .config import config
+from .util import do_respond
+
+secsPerUnit = {
+    "days": 60 * 60 * 24,
+    "hours": 60 * 60,
+    "minutes": 60,
+    "mins": 60,
+    "seconds": 1
+}
+
+class Rule(object):
+    def __init__(self, controller, scheduler, url, rule, logger_getter):
+        self.logger = logger_getter("Rule(%s -> %s)"%(rule, url))
+        self.controller = controller
+        self.scheduler = scheduler
+        self.url = url
+        self.rule = rule
+        self.exact = len(rule) == 5 # 17:00
+        self.words = rule.split(" ")
+        self.timer = timeout(None, self.trigger)
+        self.parse()
+
+    def trigger(self):
+        self.logger.info("trigger: %s (%s)"%(self.url, getattr(self, "seconds", self.rule)))
+        self.controller.trigger_handler(self.url, self.url[1:],
+            option=self.rule.endswith("nothread") and "nothread")
+        if not self.exact and not self.rule.startswith("on start"):
+            self.scheduler.update(self)
+        return True
+
+    def start(self):
+        if self.rule.startswith("on start"):
+            return
+        self.logger.info("start (%s seconds)"%(self.seconds,))
+        self.timer.add(self.seconds)
+        if self.exact:
+            self.timer.delay = 60 * 60 * 24
+        else:
+            ff = self.scheduler.ff(self)
+            if ff:
+                self.logger.info("rescheduled for %s seconds"%(self.timer.delay - ff,))
+                self.timer.expiration -= ff
+
+    def parse(self):
+        self.logger.info("parse")
+        if self.exact:
+            hours, mins = self.rule.split(":")
+            n = datetime.now()
+            t = datetime(n.year, n.month, n.day, int(hours), int(mins))
+            self.seconds = (t - n).seconds
+        elif self.rule.startswith("on start"):
+            self.logger.info("triggering start script")
+            self.trigger()
+        elif len(self.words) == 3 and self.words[0] == "every": # every [NUMBER] [UNIT]
+            num = int(self.words[1])
+            unit = self.words[2]
+            self.seconds = num * secsPerUnit[unit]
+        else: # we can implement more later...
+            self.logger.error("can't parse: %s"%(self.rule,))
+
+class Scheduler(object):
+    def __init__(self, logger_getter):
+        self.logger_getter = logger_getter
+        self.logger = logger_getter("Scheduler")
+        self.tsfile = os.path.join(os.path.abspath("."), "cron.ts")
+        self.lasts = read(self.tsfile, isjson=True, default={})
+        self.logger.info("initialized with %s timestamps"%(len(self.lasts.keys()),))
+        self.logger.info("saving state to timestamp file at %s"%(self.tsfile,))
+
+    def update(self, rule):
+        self.lasts[rule.url] = time.time()
+        self.logger.info("updating %s timestamp to %s"%(rule.url, self.lasts[rule.url]))
+        write(self.lasts, self.tsfile, isjson=True)
+
+    def ff(self, rule):
+        if rule.url in self.lasts:
+            ff = min(rule.seconds, time.time() - self.lasts[rule.url])
+            self.logger.info("fast-forwarding %s %s seconds"%(rule.url, ff))
+            return ff
+        elif config.cron.catchup:
+            self.logger.info("catching up %s"%(rule.url,))
+            return rule.seconds
+
+class Cron(object):
+    def __init__(self, controller, logger_getter):
+        self.logger_getter = logger_getter
+        self.logger = logger_getter("Cron")
+        self.scheduler = Scheduler(logger_getter)
+        self.controller = controller
+        self.timers = {}
+        self.parse()
+        self.start()
+
+    def parse(self):
+        self.logger.info("parse")
+        url = None
+        for line in read("cron.yaml", True):
+            if line.startswith("- description: "):
+                self.logger.info("initializing %s"%(line[15:],))
+            elif line.startswith("  url: "):
+                url = line[7:].strip()
+            elif url:
+                self.timers[url] = Rule(self.controller, self.scheduler,
+                    url, line[12:].strip(), self.logger_getter)
+                url = None
+
+    def start(self):
+        self.logger.info("start")
+        for rule in list(self.timers.values()):
+            rule.start()

babyweb/daemons.py

@@ -0,0 +1,45 @@
+import sys
+from dez.memcache import get_memcache
+from dez.http.application import HTTPApplication
+from .logger import logger_getter
+from .routes import static, cb
+from .config import config
+sys.path.insert(0, ".") # for dynamically loading modules
+
+class WebBase(HTTPApplication):
+    def __init__(self, bind_address, port, logger_getter, static=static, cb=cb, whitelist=[], blacklist=[], shield=False, mempad=0):
+        isprod = config.mode == "production"
+        HTTPApplication.__init__(self, bind_address, port, logger_getter, "dez/cantools",
+            config.ssl.certfile, config.ssl.keyfile, config.ssl.cacerts,
+            isprod, config.web.rollz, isprod, whitelist, blacklist, shield, mempad, config.web.xorigin)
+        self.memcache = get_memcache()
+        self.handlers = {}
+        for key, val in list(static.items()):
+            self.add_static_rule(key, val)
+        for key, val in list(cb.items()):
+            self.add_cb_rule(key, self._handler(key, val))
+
+    def _handler(self, rule, target):
+        self.logger.info("setting handler: %s %s"%(rule, target))
+        def h(req):
+            self.logger.info("triggering handler: %s %s"%(rule, target))
+            self.controller.trigger_handler(rule, target, req)
+        return h
+
+class Web(WebBase):
+    def __init__(self, bind_address, port, logger_getter, shield, mempad):
+        self.logger = logger_getter("Web")
+        wcfg = config.web
+        WebBase.__init__(self, bind_address, port, logger_getter,
+            whitelist=wcfg.whitelist, blacklist=wcfg.blacklist, shield=shield, mempad=mempad)
+
+webs = {}
+def addWeb(name, daemon, cfg):
+    webs[name] = daemon
+    if config.webs[name]:
+        for key, val in cfg.items():
+            config.webs[name].update(key, val)
+    else:
+        config.webs.update(name, cfg)
+
+addWeb("web", Web, config.web)

babyweb/logger.py

@@ -0,0 +1,48 @@
+import tracemalloc, psutil, rel
+from fyg.util import log as syslog
+from dez.logging import get_logger_getter
+from .config import config
+
+logger_getter = get_logger_getter("httpd", syslog, config.log.allow)
+
+def log(*args, **kwargs):
+    print(args, kwargs)
+
+# setters (see above)
+def setlog(f):
+    global log
+    log = f
+
+TMSNAP = None
+
+def log_tracemalloc():
+	global TMSNAP
+	snapshot = tracemalloc.take_snapshot()
+	log("[LINEMALLOC START]", important=True)
+	if TMSNAP:
+		lines = snapshot.compare_to(TMSNAP, 'lineno')
+	else:
+		lines = snapshot.statistics("lineno")
+	TMSNAP = snapshot
+	for line in lines[:10]:
+		log(line)
+	log("[LINEMALLOC END]", important=True)
+	return True
+
+PROC = None
+
+def log_openfiles():
+	global PROC
+	if not PROC:
+		PROC = psutil.Process(os.getpid())
+	ofz = PROC.open_files()
+	if config.log.oflist:
+		log("OPEN FILES: %s"%(ofz,), important=True)
+	else:
+		log("OPEN FILE COUNT: %s"%(len(ofz),), important=True)
+	return True
+
+def log_kernel():
+	log(json.dumps(rel.report()), "kernel")
+	return True
+

babyweb/mail.py

@@ -0,0 +1,25 @@
+from catmail import Mailer, Reader, Scanner
+from catmail import config as catfyg
+from .config import config
+
+mfg = config.mail
+catfyg.set({
+	"html": mfg.html,
+	"gmailer": mfg.gmailer,
+	"scantick": mfg.scantick,
+	"verbose": mfg.verbose,
+	"cache": config.cache
+})
+catfyg.admin.update("contacts", config.admin.contacts)
+catfyg.admin.update("reportees", config.admin.reportees)
+
+mailer = Mailer(mfg.mailer, mfg.name)
+send_mail = mailer.mail
+email_admins = mailer.admins
+email_reportees = mailer.reportees
+
+reader = Reader(config.mailer)
+check_inbox = reader.inbox
+
+scanner = Scanner(reader)
+on_mail = scanner.on

babyweb/memcache.py

@@ -0,0 +1,25 @@
+from .controller import dweb
+
+def getmem(key, tojson=True):
+	return dweb().memcache.get(key, tojson)
+
+def setmem(key, val, fromjson=True):
+	dweb().memcache.set(key, val, fromjson)
+
+def delmem(key):
+	dweb().memcache.rm(key)
+
+def clearmem():
+	dweb().memcache.clear()
+
+def getcache():
+	c = {}
+	orig = dweb().memcache.cache
+	for k, v in list(orig.items()):
+		if v.__class__ == set:
+			v = list(v)
+		elif v.__class__ == dict and "ttl" in v: # countdown
+			v = str(v)
+		c[k] = v
+	return c
+

babyweb/requesters.py

@@ -0,0 +1,98 @@
+import time, requests, json
+from dez.http import fetch as dfetch, post as dpost
+from fyg.util import log
+from .util import rec_conv
+
+def _ctjson(result):
+	if hasattr(result, "decode"):
+		result = result.decode()
+	code = result[0]
+	if code not in "0123":
+		log("response encoded:")
+		log(result)
+		log("attempting decode")
+		result = dec(result)
+	if code in "02":
+		log("request failed!! : %s"%(result,), important=True)
+	elif code == "3":
+		return rec_conv(json.loads(result[1:]), True)
+	else:
+		return json.loads(result[1:])
+
+def parse_url_parts(host, path, port, protocol):
+	if "://" in host:
+		protocol, host = host.split("://", 1)
+		if "/" in host:
+			host, path = host.split("/", 1)
+			path = "/" + path
+		else:
+			path = "/"
+	if ":" in host:
+		host, port = host.split(":")
+		port = int(port)
+	elif not port:
+		port = protocol == "https" and 443 or 80
+	return host, path, port, protocol
+
+def fetch(host, path="/", port=None, asjson=False, cb=None, timeout=1, asyn=False, protocol="http", ctjson=False, qsp=None, fakeua=False, retries=5):
+	host, path, port, protocol = parse_url_parts(host, path, port, protocol)
+	if qsp:
+		path += "?"
+		for k, v in list(qsp.items()):
+			path += "%s=%s&"%(k, v)
+		path = path[:-1]
+	gkwargs = {}
+	headers = {}
+	if fakeua:
+		if type(fakeua) is str:
+			headers['User-Agent'] = fakeua
+		else:
+			headers['User-Agent'] = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.75 Safari/537.36'
+		gkwargs["headers"] = headers
+	if asyn or cb: # asyn w/o cb works, will just log
+		secure = protocol == "https"
+		if ctjson:
+			orig_cb = cb or log
+			cb = lambda v : orig_cb(_ctjson(v))
+		return dfetch(host, path, port, secure, headers, cb, timeout, asjson)
+	if timeout:
+		gkwargs["timeout"] = timeout
+	furl = "%s://%s:%s%s"%(protocol, host, port, path)
+	log("fetch %s"%(furl,))
+	return syncreq(furl, "get", asjson, ctjson, retries, gkwargs)
+
+def post(host, path="/", port=80, data=None, protocol="http", asjson=False, ctjson=False, text=None, cb=None):
+	if ctjson:
+		data = rec_conv(data)
+	if cb:
+		if ctjson:
+			orig_cb = cb
+			cb = lambda v : orig_cb(_ctjson(v))
+		host, path, port, protocol = parse_url_parts(host, path, port, protocol)
+		return dpost(host, path, port, protocol == "https", data=data, text=text, cb=cb)
+	url = "://" in host and host or "%s://%s:%s%s"%(protocol, host, port, path)
+	log("post %s"%(url,))
+	kwargs = {}
+	if data:
+		kwargs["json"] = data
+	elif text:
+		kwargs["data"] = text
+	return syncreq(url, "post", asjson, ctjson, rekwargs=kwargs)
+
+def _dosyncreq(requester, url, asjson, ctjson, rekwargs):
+	result = requester(url, **rekwargs).content
+	if ctjson:
+		return _ctjson(result)
+	return asjson and json.loads(result) or result
+
+def syncreq(url, method="get", asjson=False, ctjson=False, retries=5, rekwargs={}):
+	attempt = 1
+	requester = getattr(requests, method)
+	while attempt < retries:
+		try:
+			return _dosyncreq(requester, url, asjson, ctjson, rekwargs)
+		except requests.exceptions.ConnectionError:
+			log("syncreq(%s %s) attempt #%s failed"%(method, url, attempt))
+			time.sleep(1)
+		attempt += 1
+	return _dosyncreq(requester, url, asjson, ctjson, rekwargs) # final try-less try

babyweb/response.py

@@ -0,0 +1,65 @@
+import json
+from rel import abort_branch, timeout
+from dez.http.server import HTTPResponse
+from .util import rec_conv, set_read, set_send, set_redir, set_header, set_close
+from .config import config
+
+files = {}
+def read_file(data_field):
+    return files.pop(data_field)
+
+class Response(object):
+    def __init__(self, request):
+        self.id = request.id
+        self.ip = request.real_ip
+        self.request = request
+        self.response = HTTPResponse(request)
+
+    def _read(self):
+        b = self.request.body or json.dumps(rec_conv(self.request.qs_params))
+#        print(b)
+        ctype = self.request.headers.get("content-type")
+        if ctype and ctype.startswith("multipart/form-data"):
+            if type(b) != bytes:
+                b = b.encode()
+            obj = {}
+            splitter, body = b.rsplit(b"\r\n", 2)[0].split(b"\r\n", 1)
+            for chunk in body.split(b"\r\n%s\r\n"%(splitter,)):
+                nameline, data = chunk.split(b"\r\n\r\n", 1)
+                nameline = nameline.decode()
+                name = nameline.split("; filename=")[0][:-1].split('name="')[1]
+                if "filename=" in nameline:
+                    signature = "%s%s"%(self.id, name)
+                    files[signature] = data
+                    obj[name] = signature
+                else:
+                    obj[name] = data
+            b = json.dumps(rec_conv(obj))
+        return b
+
+    def _send(self, *args, **kwargs):
+        wcfg = config.web
+        if wcfg.xorigin:
+            self.response.headers["Access-Control-Allow-Origin"] = "*"
+        if wcfg.csp:
+            if wcfg.csp.startswith("auto"):
+                d = wcfg.domain
+                if wcfg.csp != "autosub":
+                    d = ".".join(d.split(".")[-2:])
+                wcfg.update("csp", "default-src 'self' %s *.%s"%(d, d))
+            self.response.headers["Content-Security-Policy"] = wcfg.csp
+        self.response.write(*args, **kwargs)
+
+    def _close(self):
+        timeout(.001, self.response.dispatch)
+        abort_branch()
+
+    def _header(self, *args, **kwargs):
+        self.response.__setitem__(*args, **kwargs)
+
+    def set_cbs(self):
+        set_read(self._read)
+        set_header(self._header)
+        set_send(self._send)
+        set_close(self._close)
+        set_redir(self.response.redirect)

babyweb/routes.py

@@ -0,0 +1,21 @@
+from fyg.util import read
+
+url = None
+static = {}
+cb = {}
+
+for line in read("app.yaml", True):
+	if line.startswith("- url: "):
+		url = line[7:].strip()
+	elif url:
+		if line.startswith("  static_dir: "):
+			target = line[14:].strip()
+			if "*" in url: # bad regex detection...
+				static[url] = target
+			else:
+				url = url.rstrip("/")
+				static[url] = static[url + "/"] = target
+			url = None
+		elif line.startswith("  script: "):
+			cb[url] = line[10:].split(".")[0]
+			url = None

babyweb/server.py

@@ -0,0 +1,47 @@
+import os, time, requests, rel, ssl, sys, json, resource, tracemalloc, psutil
+from fyg.util import log, set_log, set_error
+from .logger import setlog, logger_getter, log_tracemalloc, log_openfiles, log_kernel
+from .controller import getController
+from .util import fail
+from .config import config
+
+def fdup():
+	log("checking the number of file descriptors allowed on your system", important=True)
+	soft, hard = resource.getrlimit(resource.RLIMIT_NOFILE)
+	half = int(hard / 2)
+	log("soft: %s. hard: %s. half: %s"%(soft, hard, half))
+	if soft < half:
+		log("increasing soft limit to half of hard limit")
+		resource.setrlimit(resource.RLIMIT_NOFILE, (half, hard))
+		log("new limits! soft: %s. hard: %s"%resource.getrlimit(resource.RLIMIT_NOFILE))
+
+def quit():
+	if config.errlog:
+		log("closing error log", important=True)
+		sys.stderr.close()
+	log("quitting - goodbye!", important=True)
+
+def run_dez_webserver():
+	if not config.ssl.verify and hasattr(ssl, "_https_verify_certificates"):
+		ssl._https_verify_certificates(False)
+	c = getController()
+	setlog(c.webs["web"].logger.simple)
+	if config.web.log:
+		set_log(os.path.join("logs", config.web.log))
+	clog = config.log
+	if clog.openfiles:
+		rel.timeout(clog.openfiles, log_openfiles)
+	if clog.tracemalloc:
+		tracemalloc.start()
+		rel.timeout(clog.tracemalloc, log_tracemalloc)
+	if "kernel" in clog.allow:
+		rel.timeout(1, log_kernel)
+	set_error(fail)
+	if config.fdup:
+		fdup()
+	if config.web.errlog:
+		sys.stderr = open(os.path.join("logs", config.web.errlog), "a")
+	c.start(quit)
+
+if __name__ == "__main__":
+	run_dez_webserver()

babyweb/shield.py

@@ -0,0 +1,53 @@
+import os
+from dez.http.server.shield import Shield
+from fyg.util import read, write
+from .logger import logger_getter
+from .config import config
+
+class PaperShield(object):
+	def __init__(self):
+		self.logger = logger_getter("PaperShield")
+		self.default = { "reason": "I'm just a paper shield!" }
+		self.ips = {}
+
+	def __call__(self, path, ip, fspath=False, count=True):
+		self.logger.access('NOOP > paperShield("%s", "%s", fspath=%s, count=%s)'%(path, ip, fspath, count))
+
+	def suss(self, ip, reason):
+		self.logger.access("suss(%s) -> %s"%(ip, reason))
+		self.ips[ip] = { "reason": reason }
+
+	def ip(self, ip):
+		return self.ips.get(ip, self.default)
+
+def setShield(blup=None):
+	shield = None
+	shfg = config.web.shield
+	if shfg: # web/admin share shield and blacklist
+		setBlacklist()
+		shield = Shield(config.web.blacklist, logger_getter, blup or writeBlacklist,
+			getattr(shfg, "limit", 400),
+			getattr(shfg, "interval", 2))
+	config.web.update("shield", shield or PaperShield())
+	return shield
+
+def setBlacklist():
+	bl = {}
+	for preban in config.web.blacklist:
+		bl[preban] = "config ban"
+	if os.path.isfile("black.list"):
+		try:
+			bsaved = read("black.list", isjson=True)
+		except: # old style
+			bsaved = {}
+			for line in read("black.list", lines=True):
+				bsaved[line.strip()] = "legacy ban"
+		bsaved and bl.update(bsaved)
+	config.web.update("blacklist", bl)
+
+def writeBlacklist():
+	wcfg = config.web
+	bl = wcfg.blacklist.obj()
+	write(bl, "black.list", isjson=True)
+	wcfg.blacklister and wcfg.blacklister.update(bl)
+	return len(bl.keys())

babyweb/sms.py

@@ -0,0 +1,11 @@
+from .mail import send_mail
+
+carriers = {
+	'at&t': 'mms.att.net',
+	'verizon': 'vtext.com',
+	'tmobile': 'tmomail.net',
+	'sprint': 'page.nextel.com'
+}
+
+def send_sms(number, subject="hello", body="goodbye", carrier="at&t"):
+	send_mail(to="%s@%s"%(number, carriers[carrier]), subject=subject, body=body)

babyweb/util/__init__.py

@@ -0,0 +1,4 @@
+from .setters import local, localvars, set_read, set_send, set_redir, set_header, set_close
+from .converters import rec_conv, rdec, renc, setenc, setdec
+from .responders import set_pre_close, do_respond, succeed, succeed_sync, fail, redirect, trysavedresponse, send_file, send_text, send_xml, send_image, send_pdf
+from .loaders import cgi_get, cgi_dump

babyweb/util/converters.py

@@ -0,0 +1,69 @@
+import json
+from urllib.parse import quote, unquote
+from base64 import b64encode, b64decode
+from six import string_types
+from ..config import config
+
+_c = config.scrambler
+_cl = len(_c)
+_chl = int(_cl / 2)
+
+def flip(c):
+    i = _c.find(c)
+    if i == -1:
+        return c
+    return _c[(i + _chl) % _cl]
+
+def scramble(s):
+    return "".join([flip(c) for c in s])
+
+def enc(data):
+    return scramble(b64encode(hasattr(data, "encode") and data.encode() or data).decode())
+
+def dec(data):
+    return data.startswith("{") and data or b64decode(scramble(data)).decode()
+
+def setenc(f):
+    global enc
+    enc = f
+
+def setdec(f):
+    global dec
+    dec = f
+
+def rdec(data):
+    return unquote(b64decode(data.encode()).decode())
+
+def renc(data):
+    return b64encode(quote(data).encode()).decode()
+
+def rec_conv(data, de=False):
+    if isinstance(data, bytes):
+        try:
+            data = data.decode()
+        except:
+            pass
+    if isinstance(data, string_types):
+        return (de and rdec or renc)(data)
+    elif isinstance(data, dict):
+        for k, v in list(data.items()):
+            data[k] = rec_conv(v, de)
+    elif isinstance(data, list):
+        return [rec_conv(d, de) for d in data]
+    return data
+
+def processResponse(data, code):
+    if code == "1":
+        try:
+            data = json.dumps(data)
+        except:
+            data = json.dumps(rec_conv(data))
+            code = "3"
+    elif code == "0":
+        try:
+            json.dumps(data)
+        except:
+            data = rec_conv(data)
+            code = "2"
+    return "%s%s"%(code, data)
+

babyweb/util/loaders.py

@@ -0,0 +1,56 @@
+import json, cgi, ast, sys
+from base64 import b64decode
+from urllib.parse import unquote
+from .setters import local, localvars
+from .converters import dec, rec_conv
+from ..config import config
+
+def qs_get(x, y):
+    val = localvars.request.getvalue(x, y)
+    if val:
+        val = unquote(val)
+    return val
+
+def cgi_read():
+    return local("read", sys.stdin.read)()
+
+def cgi_dump():
+    return local("request_string")
+
+def cgi_load():
+    localvars.request_string = cgi_read()
+    data = config.encode and dec(localvars.request_string) or localvars.request_string
+    try:
+        try:
+            jdata = json.loads(data)
+        except:
+            jdata = ast.literal_eval(data)
+        try:
+            localvars.request = rec_conv(jdata, True)
+        except:
+            localvars.request = jdata
+    except:
+        localvars.request = cgi.FieldStorage()
+        setattr(localvars.request, "get", qs_get)
+    if not localvars.request:
+        localvars.request = {}
+
+def cgi_get(key, choices=None, required=True, default=None, shield=False, decode=False, base64=False):
+    from .responders import fail
+    request = local("request")
+    val = request.get(key, default)
+    if val is None:
+        required and fail('no value submitted for required field: "%s" [%s]'%(key, request))
+    elif shield:
+        ip = local("ip")
+        shield = config.web.shield
+        if shield(val, ip, fspath=True, count=False):
+            log('cgi_get() shield bounced "%s" for "%s"'%(ip, shield.ip(ip)["message"]))
+            fail()
+    if choices and val not in choices:
+        fail('invalid value for "%s": "%s"'%(key, val))
+    if base64 and val:
+        val = b64decode(unquote(val))
+    if decode and val:
+        val = unquote(val)
+    return val

babyweb/util/responders.py

@@ -0,0 +1,199 @@
+import sys, rel, traceback
+from urllib.parse import unquote
+from fyg.util import basiclog as log
+from .converters import enc, dec, rec_conv, processResponse
+from .setters import local
+from .loaders import cgi_load
+from ..config import config
+
+def _send(data):
+    send = local("send")
+    if send:
+        send(data)
+    else:
+        print(data)
+
+def _close():
+    local("close", sys.exit)()
+
+def _pre_close():
+    pass
+
+def set_pre_close(f):
+    global _pre_close
+    _pre_close = f
+
+def _env(html):
+    return "%s"
+
+def set_env(f):
+    global _env
+    _env = f
+
+def _header(hkey, hval):
+    header = local("header")
+    if header:
+        header(hkey, hval)
+    else:
+        _send("%s: %s"%(hkey, hval))
+
+def _headers(headers):
+    for k, v in list(headers.items()):
+        _header(k, v)
+    if config.web.server == "gae":
+        _send("")
+
+def _write(data, exit=True, savename=None):
+    if savename:
+        from ..memcache import setmem
+        setmem(savename, data, False)
+    _send(data)
+    if exit:
+        _pre_close()
+        _close()
+
+FILETYPES = {"pdf": "application/pdf", "img": "image/png", "ico": "image/ico", "html": "text/html"}
+
+def send_pdf(data, title=None):
+    if title:
+        _headers({
+            "Content-Type": 'application/pdf; name="%s.pdf"'%(title,),
+            "Content-Disposition": 'attachment; filename="%s.pdf"'%(title,)
+        })
+    else:
+        _headers({"Content-Type": "application/pdf"})
+    _send(data)
+    _close()
+
+def send_image(data):
+    _headers({"Content-Type": "image/png"})
+    _send(data)
+    _close()
+
+def send_file(data, file_type=None, detect=False, headers={}):
+    if detect:
+        import magic
+        file_type = data and magic.from_buffer(data, True)
+    if file_type:
+        headers["Content-Type"] = FILETYPES.get(file_type, file_type)
+    _headers(headers)
+    _send(data)
+    _close()
+
+def send_text(data, dtype="html", fname=None, exit=True, headers={}):
+    headers["Content-Type"] = "text/%s"%(dtype,)
+    if fname:
+        headers['Content-Disposition'] = 'attachment; filename="%s.%s"'%(fname, dtype)
+    _headers(headers)
+    _write(data, exit)
+
+def send_xml(data):
+    send_text(data, "xml")
+
+def trysavedresponse(key=None):
+    from ..memcache import getmem
+    key = key or local("request_string")
+    response = getmem(key, False)
+    response and _write(response, exit=True)
+
+def redirect(addr, msg="", noscript=False, exit=True, metas=None):
+    a = "<script>"
+    if msg:
+        a += 'alert("%s"); '%(msg,)
+    a += "document.location = '%s';</script>"%(addr,)
+    if noscript:
+        a += '<noscript>This site requires Javascript to function properly. To enable Javascript in your browser, please follow <a href="http://www.google.com/support/bin/answer.py?answer=23852">these instructions</a>. Thank you, and have a nice day.</noscript>'
+    if metas:
+        a = "<html><head>%s%s</head><body></body></html>"%(metas, a)
+    _header("Content-Type", "text/html")
+    _write(_env(True)%(a,), exit)
+
+def resp_wrap(resp, failure):
+    def f():
+        try:
+            resp()
+        except rel.errors.AbortBranch as e:
+            _pre_close()
+            raise rel.errors.AbortBranch() # handled in rel
+        except SystemExit:
+            pass
+        except Exception as e:
+            failure(e)
+    return f
+
+def succeed_sync(func, cb):
+    d = {}
+    def handle(*a, **k):
+        d["a"] = a
+        d["k"] = k
+    func(handle)
+    while True:
+        time.sleep(0.01)
+        if d["a"] or d["k"]:
+            succeed(cb(*d["a"], **d["k"]))
+
+def succeed(data="", html=False, noenc=False, savename=None, cache=False):
+    if cache or config.memcache:
+        savename = local("request_string")
+    _header("Content-Type", "text/%s"%(html and "html" or "plain"))
+    draw = processResponse(data, "1")
+    dstring = (config.encode and not noenc) and enc(draw) or draw
+    _write(_env(html)%(dstring,), savename=savename)
+
+def fail(data="failed", html=False, err=None, noenc=False, exit=True):
+    if err:
+        # log it
+        logdata = "%s --- %s --> %s"%(data, repr(err), traceback.format_exc())
+        log("error:", logdata)
+        if config.web.debug:
+            # write it
+            data = logdata
+        resp = local("response")
+        reqstring = local("request_string")
+        path = resp and resp.request.url or "can't find path!"
+        ip = local("ip") or (resp and resp.ip or "can't find ip!")
+        edump = "%s\n\n%s\n\n%s\n\n%s"%(path, ip, reqstring, logdata)
+        shield = config.web.shield
+        if reqstring and shield(reqstring, ip):
+            data = "nabra"
+            reason = shield.ip(ip)["message"]
+            logline = "%s - IP (%s) banned!"%(reason, ip)
+            edump = "%s\n\n%s"%(logline, edump)
+            log(logline)
+        elif config.web.eflags:
+            samples = {
+                "traceback": logdata
+            }
+            if reqstring:
+                samples["request"] = reqstring
+            for sample in samples:
+                for ef in config.web.eflags:
+                    if ef in samples[sample]:
+                        reason = '"%s" in %s'%(ef, sample)
+                        logline = "%s - IP (%s) banned!"%(reason, ip)
+                        edump = "%s\n\n%s"%(logline, edump)
+                        shield.suss(ip, reason)
+                        log(logline)
+        if config.web.report:
+            from .mail import email_admins
+            email_admins("error encountered", edump)
+    _header("Content-Type", "text/%s"%(html and "html" or "plain"))
+    draw = processResponse(data, "0")
+    dstring = (config.encode and not noenc) and enc(draw) or draw
+    _write(_env(html)%(dstring,), exit)
+
+def do_respond(responseFunc, failMsg="failed", failHtml=False, failNoEnc=False, noLoad=False, threaded=False, response=None, autowin=True):
+    def resp():
+        response and response.set_cbs()
+        noLoad or cgi_load()
+        responseFunc()
+        autowin and succeed()
+
+    def failure(e):
+        fail(data=failMsg, html=failHtml, err=e, noenc=failNoEnc)
+
+    wrapped_response = resp_wrap(resp, failure)
+    if threaded:
+        rel.thread(wrapped_response)
+    else:
+        wrapped_response()

babyweb/util/setters.py

@@ -0,0 +1,20 @@
+import threading
+
+localvars = threading.local()
+def local(key, fallback=None):
+    return getattr(localvars, key, fallback)
+
+def set_read(f):
+    localvars.read = f
+
+def set_send(f):
+    localvars.send = f
+
+def set_redir(f):
+    localvars.redir = f
+
+def set_header(f):
+    localvars.header = f
+
+def set_close(f):
+    localvars.close = f

babyweb/version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

babyweb-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 bubbleboy14
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

babyweb-0.1.0.dist-info/METADATA

@@ -0,0 +1,19 @@
+Metadata-Version: 2.1
+Name: babyweb
+Version: 0.1.0
+Summary: Basic Asynchronous weB librarY
+Author: Mario Balibrera
+Author-email: mario.balibrera@gmail.com
+License: MIT License
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+License-File: LICENSE
+Requires-Dist: dez >=0.10.10.42
+Requires-Dist: fyg >=0.1.7.6
+
+repackages async dez components like HTTPApplication and SocketController into a minimalist config-driven web (backend) framework

babyweb-0.1.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+babyweb/__init__.py,sha256=ePOo3Lx3DdhdOrDMae2PHhOLr8SqNh81c2wN0h5JRNQ,404
+babyweb/config.py,sha256=eCvjUDqgRxOg8c8puKdf1rSrJFL87GwZVX3dclSF_ic,1025
+babyweb/controller.py,sha256=zuP_h0y9o2G98QVp_DqtgPDPOJIzGARizQzG5Aozv-g,2734
+babyweb/cron.py,sha256=wQTtY3ZJBeTjvQFbMDmR83c-aQjfEmulzeBWKUob55E,4243
+babyweb/daemons.py,sha256=4rPZyIdjBbYQ4pwSY_W2vkFY3KfvpvBEfEivkwTlE5Y,1840
+babyweb/logger.py,sha256=R8X2gci31CzLx-eWSiCdm8P4RqAYGT0EU683Y3qZf34,1021
+babyweb/mail.py,sha256=A7FL99zDU9Y_LAZPpw9-LWOsxuc1eoiGMN1EYVrwOIo,607
+babyweb/memcache.py,sha256=W6JWcBjJPZx8RPYQXYRbCWMl-ziwy9OtzCvxV9RlCXs,484
+babyweb/requesters.py,sha256=ZrnhYbYkjM7Z0JrwwRrxI5dt7pW9g2Y4EokDtD6A2NY,3197
+babyweb/response.py,sha256=_2hY9ib39MG59nvLDKD37pNCFF9ENuydegBQsd0KV18,2328
+babyweb/routes.py,sha256=V9EQKjWqbwWrR1t4Ren9IGAcmcS5awYCIHdseWoEqVU,483
+babyweb/server.py,sha256=iK0bORQGrO2sZxBcSDl9_ACNGlBVpuKh9XR-TwigGWI,1579
+babyweb/shield.py,sha256=uB4vDKf6jKwWIebAjitm_q9T86iKPRKPNNeKcPgLfrE,1551
+babyweb/sms.py,sha256=lYQFgpFjAas1XIolE0QC4ro2wgXH7hruzV1Dxz72-sE,299
+babyweb/version.py,sha256=Pru0BlFBASFCFo7McHdohtKkUtgMPDwbGfyUZlE2_Vw,21
+babyweb/util/__init__.py,sha256=zia5MMGy8m3KR6HrZ5b3l9lE3kubg4p7r0sr9vAMoPA,352
+babyweb/util/converters.py,sha256=tvAppsy79lrhkOi3E2LkdBpEJ__j0H22RSiKJHssMGs,1579
+babyweb/util/loaders.py,sha256=kMNxQ-hN-oJVgrOU8TQU8LSqp6B3wMoUKOpgS1D5R6Y,1752
+babyweb/util/responders.py,sha256=A8RF3AR32H9z3YAEFCTmIQQuQ_yUoSub7u0Txnv8YYk,6194
+babyweb/util/setters.py,sha256=xIHtdLQgdlyCUC83q3ZW8ab6U5Rj3UU6ZgK70b-TOg4,337
+babyweb-0.1.0.dist-info/LICENSE,sha256=TCGFq2RZnPZed3cKBhfq8EIxNzHcwJWJsBW8p9y1dDk,1068
+babyweb-0.1.0.dist-info/METADATA,sha256=zItkGAOsx5Z4dfMaX8wvI-Y6w7KCtAVQBPXFFl4eqfI,727
+babyweb-0.1.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+babyweb-0.1.0.dist-info/top_level.txt,sha256=-KcZVMe9-tSS5gwyDZGyLvU5bemV6aWTSofb0B37Mts,8
+babyweb-0.1.0.dist-info/RECORD,,

babyweb-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.42.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

babyweb-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+babyweb