squashme: redo bot api

Author: majestrate

docs/bot-api.md

@@ -6,66 +6,7 @@ zmq commands:
 
 * [sogs.sub](#sub)
 * [sogs.unsub](#unsub)
-
-* [sogs.user.info](#user-info)
-* [sogs.user.send](#user-send)
-* [sogs.user.perm](#user-perm)
-* [sogs.user.ban](#user-ban)
-* [sogs.user.unban](#user-unban)
-
-* [sogs.room.info](#room-info)
-* [sogs.room.send](#room-send)
-* [sogs.room.perm](#room-perm)
-
-* [sogs.file.info](#file-info)
-* [sogs.file.upload](#file-upload)
-* [sogs.file.del](#file-del)
-* [sogs.file.ban](#file-ban)
-* [sogs.file.unban](#file-ban)
-
-
-# Objects
-
-## UserInfo
-
-a dict containing info on a user
-
-* id - the integer id for this user
-* pubkey - the user's 32 byte public x25519 key, session id is 0x05 then the pubkey bytes all hex encoded
-* names - a dict of room token as key and displayed name in that room
-* mod - if the user is a moderator positive non zero otherwise zero
-
-## RoomInfo
-
-a dict containing info on a room
-
-* id - the integer id for this room
-* token - the name of this room used in the url
-* users - a list of UserInfo of all the users in the room (optional)
-
-## FileInfo
-
-a dict describing a file
-
-* id - internal id for referring to this file
-* public-url - a public url to fetch the file at
-* size - the size of this file in bytes
-* mimetype - the implied mimetpye of this file
-* uploaded - the time this file was uploaded at in milliseconds since unix epoch
-* hashes - a dict of hash algorithm name to the digest value of the file with that algorithm (currently supported algorithms: blake2 / sha2-256 / sha1 / md5 )
-* user - the user id of who uploaded this file
-
-## PostInfo
-
-a dict describing a post made to a room
-
-* id - the post's id
-* user - the id of the user that posted the message
-* room - the id of the room that the message was posted in
-* when - the time this message was recieved in the room as milliseconds since unix epoch
-* text - the plaintext body of the message as a string
-* files - a list of file ids this message uploaded files with (optional)
-* cites - a post id this post is citing (optional)
+* [sogs.request](#request)
 
 
 # Events
@@ -112,54 +53,10 @@ subscribe to events
 
 unsubscribe to events
 
-## sogs.user.info <span id="user-info" />
-
-fetch info of a user
-
-## sogs.user.send <span id="user-send" />
-
-send a whisper to a user
-
-## sogs.user.perm <span id="user-perm" />
-
-get/set user permissions (read/write/upload)
-
-## sogs.user.ban <span id="user-ban" />
-
-ban user
-
-## sogs.user.unban <span id="user-unban" />
-
-unban user
-
-## sogs.room.info <span id="room-info" />
-
-get/set room info
-
-## sogs.room.send <span id="room-send" />
-
-send a message to the room
-
-## sogs.room.perm <span id="room-perm" />
-
-get/set room permissions (read/write/upload)
-
-## sogs.file.info <span id="file-info" />
-
-get uploaded file info
-
-## sogs.file.upload <span id="file-upload" />
-
-upload a file
-
-## sogs.file.del <span id="file-del" />
-
-delete a file
-
-## sogs.file.ban <span id="file-ban" />
+## sogs.request <span id="request" />
 
-ban file uploads by mimetype/hash/etc optionally per room
+call an http api endpoint
 
-## sogs.file.unban <span id="file-unban" />
+args: [method, path, headers_dict, optional_body]
 
-unban uploads by mimetype/hash/etc optionally per room
+returns: [http_status, headers_dict, response_bytes]

sogs/events.py

@@ -2,12 +2,16 @@
 
 from oxenmq import AuthLevel
 
+from . import config
 from . import model
 from .omq import omq
 
 from binascii import hexlify
 
 from oxenc import bt_serialize as serialize
+from oxenc import bt_deserialize as deserialize
+
+from requests import request as http_request
 
 # pools for event propagation
 _pools = defaultdict(list)
@@ -21,7 +25,7 @@
 
 def event_name_valid(eventname):
     """ return True if this event name is something well formed """
-    return eventname.lower() in EVENTS
+    return eventname in EVENTS
 
 
 def _user_from_conn(conn, automod=True):
@@ -43,72 +47,29 @@ def _sub_conn_to_event(name, conn):
     _pools[name].append(conn)
 
 
+def _unsub_conn_from_event(name, conn):
+    if not event_name_valid(name):
+        raise Exception(f"invalid event: {name}")
+    global _pool
+    _pools[name].remove(conn)
+
+
 def _handle_subscribe_request(msg):
     """ handle a request to subscribe to events as a bot"""
     parts = msg.data()
     if len(parts) == 0:
         raise Exception("no events selected")
-
     for name in parts:
-        name = name.decode()
-        _sub_conn_to_event(name, msg.conn)
-
-
-def _handle_find_room(metric, query):
-    """ find a room """
-    if metric == 'id':
-        room = model.Room(id=int(query))
-    elif metric == 'token':
-        room = model.Room(token=query)
-    else:
-        raise Exception("invalid query metric: {}".format(metric))
-    reply = {a: getattr(room, a) for a in model.Room.ALL_PROPS}
-    reply['mods'] = room.get_mods()
-    reply['active_users'] = room.active_users()
-    return reply
-
-
-def _handle_find_user(metric, query):
-    """ find a user """
-    if metric == 'id':
-        user = model.User(id=int(query))
-    elif metric == 'pubkey':
-        user = model.User(session_id=query)
-    else:
-        raise Exception("invalid query metric: {}".format(metric))
-    reply = {a: getattr(user, a) for a in model.User.ALL_PROPS}
-    return reply
-
-
-def _handle_find_request(msg):
-    """ finds a user / room by id / token / pubkey """
-    parts = msg.data()
-    if len(parts) != 3:
-        raise Exception('3 arguments required: entity-kind, query-metric, query-value')
+        _sub_conn_to_event(name.decode(), msg.conn)
 
-    kind = parts[0].decode('utf-8')
-    metric = parts[1].decode('utf-8')
-    query = parts[2].decode('utf-8')
 
-    _kinds = {'room': _handle_find_room, 'user': _handle_find_user}
-
-    if kind in _kinds:
-        return _kinds[kind](metric, query)
-    raise Exception("cannot find a '{}' we dont have those".format(kind))
-
-
-def _handle_mod_ban(msg):
-    """ handle a ban user from room rqeuest """
+def _handle_unsubscribe_request(msg):
+    """ unusb from events """
     parts = msg.data()
-    if len(parts) < 2:
-        raise Exception("Not enough arguments, need 2 arguments: user_id, room_id")
-    room_id = int(parts[1])
-    user_id = int(parts[0])
-    room = model.Room(id=room_id)
-    ban_user = model.User(id=user_id)
-    bot = _user_from_conn(msg.conn)
-    if not model.ban_user(bot, room, ban_user):
-        raise Exception("user not banned")
+    if len(parts) == 0:
+        raise Exception("no events selected")
+    for name in parts:
+        _unsub_conn_from_event(name.decode(), msg.conn)
 
 
 def _propagate_event(eventname, *args):
@@ -121,33 +82,68 @@ def _propagate_event(eventname, *args):
 
 
 def _handle_request(handler, msg):
-    """ safely handle a request handler and catch any exceptions that happen and propagate them to the remote connection """
+    """safely handle a request handler and catch any exceptions that happen and propagate them to
+    the remote connection"""
     try:
         retval = handler(msg)
         if retval is None:
             msg.reply(status_OK)
+        elif isinstance(retval, tuple):
+            msg.reply(status_OK, *retval)
         else:
             msg.reply(status_OK, serialize(retval))
     except Exception as ex:
         msg.reply(status_ERR, '{}'.format(ex))
 
 
+def _handle_api_request(msg):
+    """ do an http api request """
+    parts = msg.parts()
+    if len(parts) < 3:
+        raise Exception("invalid number of parts {}".format(len(parts)))
+    kwargs = dict()
+    if len(parts) >= 4:
+        kwargs['body'] = parts[3]
+
+    headers = deserialize(parts[2])
+    if not isinstance(headers, dict):
+        raise ValueError("headers is not a dict")
+
+    kwargs['headers'] = headers
+
+    path = parts[1].decode()
+    if not path.startswith("/"):
+        raise ValueError("invalid request path")
+    method = parts[0].decode()
+    resp = http_request(method, config.URL_BASE + path, **kwargs)
+
+    headers = dict()
+    for k, v in resp.headers.items():
+        headers[k] = v
+
+    return serialize(resp.status_code), serialize(headers), resp.content
+
+
 def setup_rpc():
     """ set up bot api using an existing oxenmq instance """
     _bot_category = omq.add_category('sogs', AuthLevel.none)
     _bot_category.add_request_command(
         'sub', lambda msg: _handle_request(_handle_subscribe_request, msg)
     )
     _bot_category.add_request_command(
-        'find', lambda msg: _handle_request(_handle_find_request, msg)
+        'unsub', lambda msg: _handle_request(_handle_unsubscribe_request, msg)
     )
-    _bot_category.add_request_command('ban', lambda msg: _handle_request(_handle_mod_ban, msg))
+    _bot_category.add_request_command(
+        'request', lambda msg: _handle_request(_handle_api_request, msg)
+    )
+
 
+class _Notify:
+    """ Holder type for all event notification functions """
 
-class Notify:
-    """ Holder for all event notification functions """
 
+notify = _Notify()
 
 # set up event notifiers
 for ev in EVENTS:
-    setattr(Notify, ev, lambda *args: _propagate_event(ev, *args))
+    setattr(notify, ev, lambda *args: _propagate_event(ev, *args))

sogs/mule.py

@@ -8,7 +8,7 @@
 from . import cleanup
 from . import config
 from . import omq as o
-from .events import setup_rpc, Notify
+from .events import setup_rpc, notify
 
 # This is the uwsgi "mule" that handles things not related to serving HTTP requests:
 # - it holds the oxenmq instance (with its own interface into sogs)
@@ -99,32 +99,32 @@ def wrapper(*args, **kwargs):
 
 @log_exceptions
 def message_posted(m: oxenmq.Message):
-    Notify.message(*m.data())
+    notify.message(*m.data())
 
 
 @log_exceptions
 def messages_deleted(m: oxenmq.Message):
-    Notify.deleted(*m.data())
+    notify.deleted(*m.data())
 
 
 @log_exceptions
 def user_banned(m: oxenmq.Message):
-    Notify.banned(*m.data())
+    notify.banned(*m.data())
 
 
 @log_exceptions
 def user_unbanned(m: oxenmq.Message):
-    Notify.unbannd(*m.data())
+    notify.unbannd(*m.data())
 
 
 @log_exceptions
 def user_joined(m: oxenmq.Message):
-    Notify.joined(*m.data())
+    notify.joined(*m.data())
 
 
 @log_exceptions
 def file_uploaded(m: oxenmq.Message):
-    Notify.uploaded(*m.data())
+    notify.uploaded(*m.data())
 
 
 @log_exceptions