Implement XMPP relaying
This commit is contained in:
454
core/management/commands/component.py
Normal file
454
core/management/commands/component.py
Normal file
@@ -0,0 +1,454 @@
|
||||
from core.util import logs
|
||||
from django.core.management.base import BaseCommand
|
||||
from slixmpp.componentxmpp import ComponentXMPP
|
||||
from django.conf import settings
|
||||
from core.models import User, Person, PersonIdentifier
|
||||
from redis import asyncio as aioredis
|
||||
import asyncio
|
||||
import msgpack
|
||||
from core.lib import deferred
|
||||
from slixmpp.xmlstream import register_stanza_plugin
|
||||
from slixmpp.plugins.xep_0085.stanza import Active, Composing, Paused, Inactive, Gone
|
||||
from slixmpp.stanza import Message
|
||||
|
||||
log = logs.get_logger("component")
|
||||
|
||||
redis = aioredis.from_url("unix://var/run/gia-redis.sock", db=10)
|
||||
|
||||
class EchoComponent(ComponentXMPP):
|
||||
|
||||
"""
|
||||
A simple Slixmpp component that echoes messages.
|
||||
"""
|
||||
|
||||
def __init__(self, jid, secret, server, port):
|
||||
super().__init__(jid, secret, server, port)
|
||||
# Register chat state plugins
|
||||
register_stanza_plugin(Message, Active)
|
||||
register_stanza_plugin(Message, Composing)
|
||||
register_stanza_plugin(Message, Paused)
|
||||
register_stanza_plugin(Message, Inactive)
|
||||
register_stanza_plugin(Message, Gone)
|
||||
|
||||
self.add_event_handler("session_start", self.session_start)
|
||||
self.add_event_handler("disconnected", self.on_disconnected)
|
||||
self.add_event_handler("message", self.message)
|
||||
|
||||
# Presence event handlers
|
||||
self.add_event_handler("presence_available", self.on_presence_available)
|
||||
self.add_event_handler("presence_dnd", self.on_presence_dnd)
|
||||
self.add_event_handler("presence_xa", self.on_presence_xa)
|
||||
self.add_event_handler("presence_chat", self.on_presence_chat)
|
||||
self.add_event_handler("presence_away", self.on_presence_away)
|
||||
self.add_event_handler("presence_unavailable", self.on_presence_unavailable)
|
||||
self.add_event_handler("presence_subscribe", self.on_presence_subscribe)
|
||||
self.add_event_handler("presence_subscribed", self.on_presence_subscribed)
|
||||
self.add_event_handler("presence_unsubscribe", self.on_presence_unsubscribe)
|
||||
self.add_event_handler("presence_unsubscribed", self.on_presence_unsubscribed)
|
||||
self.add_event_handler("roster_subscription_request", self.on_roster_subscription_request)
|
||||
|
||||
# Chat state handlers
|
||||
self.add_event_handler("chatstate_active", self.on_chatstate_active)
|
||||
self.add_event_handler("chatstate_composing", self.on_chatstate_composing)
|
||||
self.add_event_handler("chatstate_paused", self.on_chatstate_paused)
|
||||
self.add_event_handler("chatstate_inactive", self.on_chatstate_inactive)
|
||||
self.add_event_handler("chatstate_gone", self.on_chatstate_gone)
|
||||
|
||||
def get_identifier(self, msg):
|
||||
# Extract sender JID (full format: user@domain/resource)
|
||||
sender_jid = str(msg["from"])
|
||||
|
||||
# Split into username@domain and optional resource
|
||||
sender_parts = sender_jid.split("/", 1)
|
||||
sender_bare_jid = sender_parts[0] # Always present: user@domain
|
||||
sender_username, sender_domain = sender_bare_jid.split("@", 1)
|
||||
|
||||
sender_resource = sender_parts[1] if len(sender_parts) > 1 else None # Extract resource if present
|
||||
|
||||
# Extract recipient JID (should match component JID format)
|
||||
recipient_jid = str(msg["to"])
|
||||
|
||||
if "@" in recipient_jid:
|
||||
recipient_username, recipient_domain = recipient_jid.split("@", 1)
|
||||
else:
|
||||
recipient_username = recipient_jid
|
||||
recipient_domain = recipient_jid
|
||||
|
||||
# Extract message body
|
||||
body = msg["body"] if msg["body"] else "[No Body]"
|
||||
# Parse recipient_name and recipient_service (e.g., "mark|signal")
|
||||
if "|" in recipient_username:
|
||||
person_name, service = recipient_username.split("|")
|
||||
person_name = person_name.title() # Capitalize for consistency
|
||||
else:
|
||||
person_name = recipient_username.title()
|
||||
service = None
|
||||
|
||||
|
||||
try:
|
||||
# Lookup user in Django
|
||||
log.info(f"User {sender_username}")
|
||||
user = User.objects.get(username=sender_username)
|
||||
|
||||
# Find Person object with name=person_name.lower()
|
||||
log.info(f"Name {person_name.title()}")
|
||||
person = Person.objects.get(user=user, name=person_name.title())
|
||||
|
||||
# Ensure a PersonIdentifier exists for this user, person, and service
|
||||
log.info(f"Identifier {service}")
|
||||
identifier = PersonIdentifier.objects.get(user=user, person=person, service=service)
|
||||
|
||||
return identifier
|
||||
|
||||
except (User.DoesNotExist, Person.DoesNotExist, PersonIdentifier.DoesNotExist):
|
||||
# If any lookup fails, reject the subscription
|
||||
return None
|
||||
|
||||
def on_chatstate_active(self, msg):
|
||||
"""
|
||||
Handle when a user is actively engaged in the chat.
|
||||
"""
|
||||
log.info(f"Chat state: Active from {msg['from']}.")
|
||||
|
||||
identifier = self.get_identifier(msg)
|
||||
|
||||
def on_chatstate_composing(self, msg):
|
||||
"""
|
||||
Handle when a user is typing a message.
|
||||
"""
|
||||
log.info(f"Chat state: Composing from {msg['from']}.")
|
||||
|
||||
identifier = self.get_identifier(msg)
|
||||
|
||||
def on_chatstate_paused(self, msg):
|
||||
"""
|
||||
Handle when a user has paused typing.
|
||||
"""
|
||||
log.info(f"Chat state: Paused from {msg['from']}.")
|
||||
|
||||
identifier = self.get_identifier(msg)
|
||||
|
||||
def on_chatstate_inactive(self, msg):
|
||||
"""
|
||||
Handle when a user is inactive in the chat.
|
||||
"""
|
||||
log.info(f"Chat state: Inactive from {msg['from']}.")
|
||||
|
||||
identifier = self.get_identifier(msg)
|
||||
|
||||
def on_chatstate_gone(self, msg):
|
||||
"""
|
||||
Handle when a user has left the chat.
|
||||
"""
|
||||
log.info(f"Chat state: Gone from {msg['from']}.")
|
||||
|
||||
identifier = self.get_identifier(msg)
|
||||
|
||||
|
||||
def on_presence_available(self, pres):
|
||||
"""
|
||||
Handle when a user becomes available.
|
||||
"""
|
||||
log.info(f"Presence available from {pres['from']}")
|
||||
|
||||
def on_presence_dnd(self, pres):
|
||||
"""
|
||||
Handle when a user sets 'Do Not Disturb' status.
|
||||
"""
|
||||
log.info(f"User {pres['from']} is now in 'Do Not Disturb' mode.")
|
||||
|
||||
def on_presence_xa(self, pres):
|
||||
"""
|
||||
Handle when a user sets 'Extended Away' status.
|
||||
"""
|
||||
log.info(f"User {pres['from']} is now 'Extended Away'.")
|
||||
|
||||
def on_presence_chat(self, pres):
|
||||
"""
|
||||
Handle when a user is actively available for chat.
|
||||
"""
|
||||
log.info(f"User {pres['from']} is now available for chat.")
|
||||
|
||||
def on_presence_away(self, pres):
|
||||
"""
|
||||
Handle when a user sets 'Away' status.
|
||||
"""
|
||||
log.info(f"User {pres['from']} is now 'Away'.")
|
||||
|
||||
def on_presence_unavailable(self, pres):
|
||||
"""
|
||||
Handle when a user goes offline or unavailable.
|
||||
"""
|
||||
log.info(f"User {pres['from']} is now unavailable.")
|
||||
|
||||
def on_presence_subscribe(self, pres):
|
||||
"""
|
||||
Handle incoming presence subscription requests.
|
||||
Accept only if the recipient has a contact matching the sender.
|
||||
"""
|
||||
|
||||
sender_jid = str(pres['from']).split('/')[0] # Bare JID (user@domain)
|
||||
recipient_jid = str(pres['to']).split('/')[0]
|
||||
|
||||
log.info(f"Received subscription request from {sender_jid} to {recipient_jid}")
|
||||
|
||||
try:
|
||||
# Extract sender and recipient usernames
|
||||
user_username, _ = sender_jid.split("@", 1)
|
||||
recipient_username, _ = recipient_jid.split("@", 1)
|
||||
|
||||
# Parse recipient_name and recipient_service (e.g., "mark|signal")
|
||||
if "|" in recipient_username:
|
||||
person_name, service = recipient_username.split("|")
|
||||
person_name = person_name.title() # Capitalize for consistency
|
||||
else:
|
||||
person_name = recipient_username.title()
|
||||
service = None
|
||||
|
||||
# Lookup user in Django
|
||||
log.info(f"User {user_username}")
|
||||
user = User.objects.get(username=user_username)
|
||||
|
||||
# Find Person object with name=person_name.lower()
|
||||
log.info(f"Name {person_name.title()}")
|
||||
person = Person.objects.get(user=user, name=person_name.title())
|
||||
|
||||
# Ensure a PersonIdentifier exists for this user, person, and service
|
||||
log.info(f"Identifier {service}")
|
||||
PersonIdentifier.objects.get(user=user, person=person, service=service)
|
||||
|
||||
# If all checks pass, accept the subscription
|
||||
self.send_presence(ptype="subscribed", pto=sender_jid)
|
||||
log.info(f"Subscription request from {sender_jid} accepted for {recipient_jid}.")
|
||||
|
||||
except (User.DoesNotExist, Person.DoesNotExist, PersonIdentifier.DoesNotExist):
|
||||
# If any lookup fails, reject the subscription
|
||||
log.warning(f"Subscription request from {sender_jid} rejected (recipient does not have this contact).")
|
||||
self.send_presence(ptype="unsubscribed", pto=sender_jid)
|
||||
|
||||
|
||||
def on_presence_subscribed(self, pres):
|
||||
"""
|
||||
Handle successful subscription confirmations.
|
||||
"""
|
||||
log.info(f"Subscription to {pres['from']} was accepted.")
|
||||
|
||||
def on_presence_unsubscribe(self, pres):
|
||||
"""
|
||||
Handle when a user unsubscribes from presence updates.
|
||||
"""
|
||||
log.info(f"User {pres['from']} has unsubscribed from presence updates.")
|
||||
|
||||
def on_presence_unsubscribed(self, pres):
|
||||
"""
|
||||
Handle when a user's unsubscription request is confirmed.
|
||||
"""
|
||||
log.info(f"Unsubscription from {pres['from']} confirmed.")
|
||||
|
||||
def on_roster_subscription_request(self, pres):
|
||||
"""
|
||||
Handle roster subscription requests.
|
||||
"""
|
||||
log.info(f"New roster subscription request from {pres['from']}.")
|
||||
|
||||
def session_start(self, *args):
|
||||
log.info("XMPP session started")
|
||||
|
||||
def on_disconnected(self, *args):
|
||||
"""
|
||||
Handles XMPP disconnection and triggers a reconnect loop.
|
||||
"""
|
||||
log.warning("XMPP disconnected, attempting to reconnect...")
|
||||
self.connect()
|
||||
|
||||
def session_start(self, *args):
|
||||
log.info(f"START {args}")
|
||||
|
||||
def message(self, msg):
|
||||
"""
|
||||
Process incoming XMPP messages.
|
||||
"""
|
||||
|
||||
sym = lambda x: msg.reply(f"[>] {x}").send()
|
||||
# log.info(f"Received message: {msg}")
|
||||
|
||||
# Extract sender JID (full format: user@domain/resource)
|
||||
sender_jid = str(msg["from"])
|
||||
|
||||
# Split into username@domain and optional resource
|
||||
sender_parts = sender_jid.split("/", 1)
|
||||
sender_bare_jid = sender_parts[0] # Always present: user@domain
|
||||
sender_username, sender_domain = sender_bare_jid.split("@", 1)
|
||||
|
||||
sender_resource = sender_parts[1] if len(sender_parts) > 1 else None # Extract resource if present
|
||||
|
||||
# Extract recipient JID (should match component JID format)
|
||||
recipient_jid = str(msg["to"])
|
||||
|
||||
if "@" in recipient_jid:
|
||||
recipient_username, recipient_domain = recipient_jid.split("@", 1)
|
||||
else:
|
||||
recipient_username = recipient_jid
|
||||
recipient_domain = recipient_jid
|
||||
|
||||
# Extract message body
|
||||
body = msg["body"] if msg["body"] else "[No Body]"
|
||||
|
||||
# Log extracted information with variable name annotations
|
||||
log_message = (
|
||||
f"Sender JID: {sender_jid}, Sender Username: {sender_username}, Sender Domain: {sender_domain}, "
|
||||
f"Sender Resource: {sender_resource if sender_resource else '[No Resource]'}, "
|
||||
f"Recipient JID: {recipient_jid}, Recipient Username: {recipient_username}, Recipient Domain: {recipient_domain}, "
|
||||
f"Body: {body}"
|
||||
)
|
||||
log.info(log_message)
|
||||
|
||||
# Ensure recipient domain matches our configured component
|
||||
expected_domain = settings.XMPP_JID # 'jews.zm.is' in your config
|
||||
if recipient_domain != expected_domain:
|
||||
log.warning(f"Invalid recipient domain: {recipient_domain}, expected {expected_domain}")
|
||||
return
|
||||
|
||||
# Lookup sender in Django's User model
|
||||
try:
|
||||
sender_user = User.objects.get(username=sender_username)
|
||||
except User.DoesNotExist:
|
||||
log.warning(f"Unknown sender: {sender_username}")
|
||||
return
|
||||
|
||||
if recipient_jid == settings.XMPP_JID:
|
||||
log.info("Message to JID")
|
||||
if body.startswith("."):
|
||||
# Messaging the gateway directly
|
||||
if body == ".contacts":
|
||||
# Lookup Person objects linked to sender
|
||||
persons = Person.objects.filter(user=sender_user)
|
||||
if not persons.exists():
|
||||
log.info(f"No contacts found for {sender_username}")
|
||||
sym("No contacts found.")
|
||||
return
|
||||
|
||||
# Construct contact list response
|
||||
contact_names = [person.name for person in persons]
|
||||
response_text = f"Contacts: " + ", ".join(contact_names)
|
||||
sym(response_text)
|
||||
elif body == ".whoami":
|
||||
sym(str(sender_user.__dict__))
|
||||
else:
|
||||
sym("No such command")
|
||||
else:
|
||||
log.info("Other message")
|
||||
if "|" in recipient_username:
|
||||
recipient_name, recipient_service = recipient_username.split("|")
|
||||
|
||||
recipient_name = recipient_name.title()
|
||||
|
||||
else:
|
||||
recipient_name = recipient_username
|
||||
recipient_service = None
|
||||
|
||||
recipient_name = recipient_name.title()
|
||||
|
||||
try:
|
||||
person = Person.objects.get(user=sender_user, name=recipient_name)
|
||||
except Person.DoesNotExist:
|
||||
sym("This person does not exist.")
|
||||
|
||||
if recipient_service:
|
||||
try:
|
||||
identifier = PersonIdentifier.objects.get(user=sender_user,
|
||||
person=person,
|
||||
service=recipient_service)
|
||||
except PersonIdentifier.DoesNotExist:
|
||||
sym("This service identifier does not exist.")
|
||||
else:
|
||||
# Get a random identifier
|
||||
identifier = PersonIdentifier.objects.filter(user=sender_user,
|
||||
person=person).first()
|
||||
recipient_service = identifier.service
|
||||
|
||||
# sym(str(person.__dict__))
|
||||
# sym(f"Service: {recipient_service}")
|
||||
|
||||
identifier.send(body)
|
||||
|
||||
def send_from_external(self, person_identifier, text, detail):
|
||||
"""
|
||||
This method will send an incoming external message to the correct XMPP user.
|
||||
"""
|
||||
|
||||
sender_jid = f"{person_identifier.person.name.lower()}|{person_identifier.service}@{settings.XMPP_JID}"
|
||||
recipient_jid = f"{person_identifier.user.username}@{settings.XMPP_ADDRESS}"
|
||||
|
||||
if detail.is_outgoing_message:
|
||||
carbon_msg = f"""
|
||||
<message xmlns="jabber:client" type="chat" from="{recipient_jid}" to="{sender_jid}">
|
||||
<received xmlns="urn:xmpp:carbons:2">
|
||||
<forwarded xmlns="urn:xmpp:forward:0">
|
||||
<message from="{recipient_jid}" to="{sender_jid}" type="chat">
|
||||
<body>{text}</body>
|
||||
</message>
|
||||
</forwarded>
|
||||
</received>
|
||||
</message>
|
||||
"""
|
||||
log.info(f"Sending Carbon: {carbon_msg}")
|
||||
self.send_raw(carbon_msg)
|
||||
else:
|
||||
|
||||
|
||||
log.info(f"Forwarding message from external service: {sender_jid} -> {recipient_jid}: {text}")
|
||||
self.send_message(mto=recipient_jid, mfrom=sender_jid, mbody=text, mtype="chat")
|
||||
|
||||
|
||||
async def stream(**kwargs):
|
||||
pubsub = redis.pubsub()
|
||||
await pubsub.subscribe("component")
|
||||
|
||||
while True:
|
||||
message = await pubsub.get_message(ignore_subscribe_messages=True)
|
||||
if message is not None:
|
||||
try:
|
||||
log.info("GOT", message)
|
||||
data = message["data"]
|
||||
unpacked = msgpack.unpackb(data, raw=False)
|
||||
log.info(f"Unpacked: {unpacked}")
|
||||
except TypeError:
|
||||
log.info(f"FAILED {message}")
|
||||
continue
|
||||
if "type" in unpacked.keys():
|
||||
if unpacked["type"] == "def":
|
||||
await deferred.process_deferred(
|
||||
unpacked,
|
||||
**kwargs
|
||||
)
|
||||
await asyncio.sleep(0.01)
|
||||
|
||||
class Command(BaseCommand):
|
||||
def handle(self, *args, **options):
|
||||
xmpp = EchoComponent(
|
||||
jid=settings.XMPP_JID,
|
||||
secret=settings.XMPP_SECRET,
|
||||
server=settings.XMPP_ADDRESS,
|
||||
port=settings.XMPP_PORT,
|
||||
)
|
||||
xmpp.register_plugin('xep_0030') # Service Discovery
|
||||
xmpp.register_plugin('xep_0004') # Data Forms
|
||||
xmpp.register_plugin('xep_0060') # PubSub
|
||||
xmpp.register_plugin('xep_0199') # XMPP Ping
|
||||
xmpp.register_plugin("xep_0085") # Chat State Notifications
|
||||
|
||||
loop = asyncio.new_event_loop()
|
||||
asyncio.set_event_loop(loop)
|
||||
loop.create_task(stream(xmpp=xmpp))
|
||||
|
||||
# Connect to the XMPP server and start processing XMPP stanzas.
|
||||
xmpp.connect()
|
||||
xmpp.process()
|
||||
|
||||
|
||||
try:
|
||||
while True:
|
||||
pass # Keep the component running
|
||||
except (KeyboardInterrupt, SystemExit):
|
||||
log.info("XMPP Component terminating")
|
||||
@@ -22,6 +22,9 @@ SIGNAL_URL = "signal:8080"
|
||||
|
||||
log = logs.get_logger("processing")
|
||||
|
||||
redis = aioredis.from_url("unix://var/run/gia-redis.sock", db=10)
|
||||
|
||||
|
||||
class HandleMessage(Command):
|
||||
async def handle(self, c: Context):
|
||||
msg = {
|
||||
@@ -36,9 +39,18 @@ class HandleMessage(Command):
|
||||
"mentions": c.message.mentions,
|
||||
"raw_message": c.message.raw_message
|
||||
}
|
||||
dest = c.message.raw_message.get("envelope", {}).get("syncMessage", {}).get("sentMessage", {}).get("destinationUuid")
|
||||
account = c.message.raw_message.get("account", "")
|
||||
source_name = msg["raw_message"].get("envelope", {}).get("sourceName", "")
|
||||
log.info("1")
|
||||
raw = json.loads(c.message.raw_message)
|
||||
print(json.dumps(c.message.raw_message, indent=2))
|
||||
#dest = c.message.raw_message.get("envelope", {}).get("syncMessage", {}).get("sentMessage", {}).get("destinationUuid")
|
||||
dest = raw.get("envelope", {}).get("syncMessage", {}).get("sentMessage", {}).get("destinationUuid")
|
||||
|
||||
#account = c.message.raw_message.get("account", "")
|
||||
account = raw.get("account", "")
|
||||
log.info("2")
|
||||
#source_name = msg["raw_message"].get("envelope", {}).get("sourceName", "")
|
||||
source_name = raw.get("envelope", {}).get("sourceName", "")
|
||||
log.info("3")
|
||||
|
||||
source_number = c.message.source_number
|
||||
source_uuid = c.message.source_uuid
|
||||
@@ -58,6 +70,21 @@ class HandleMessage(Command):
|
||||
# Determine the identifier to use
|
||||
identifier_uuid = dest if is_from_bot else source_uuid
|
||||
|
||||
cast = {
|
||||
"type": "def",
|
||||
"method": "xmpp",
|
||||
"service": "signal",
|
||||
# "sender": source_uuid,
|
||||
"identifier": identifier_uuid,
|
||||
"msg": text,
|
||||
"detail": {
|
||||
"reply_to_self": reply_to_self,
|
||||
"reply_to_others": reply_to_others,
|
||||
"is_outgoing_message": is_outgoing_message,
|
||||
}
|
||||
}
|
||||
packed = msgpack.packb(cast, use_bin_type=True)
|
||||
await redis.publish("component", packed)
|
||||
|
||||
# TODO: Permission checks
|
||||
manips = await sync_to_async(list)(
|
||||
@@ -116,8 +143,14 @@ class HandleMessage(Command):
|
||||
text=result,
|
||||
ts=ts + 1,
|
||||
)
|
||||
log.info("NOT SENDING CHECK CODE IS OK")
|
||||
# log.info("NOT SENDING CHECK CODE IS OK")
|
||||
# await natural.natural_send_message(c, result)
|
||||
tss = await natural.natural_send_message(
|
||||
result,
|
||||
c.send,
|
||||
c.start_typing,
|
||||
c.stop_typing,
|
||||
)
|
||||
elif manip.mode == "notify":
|
||||
title = f"[GIA] Suggested message to {person_identifier.person.name}"
|
||||
manip.user.sendmsg(result, title=title)
|
||||
@@ -180,8 +213,7 @@ class HandleMessage(Command):
|
||||
)
|
||||
#
|
||||
|
||||
async def pubsub():
|
||||
redis = aioredis.from_url("unix://var/run/gia-redis.sock", db=10)
|
||||
async def stream():
|
||||
pubsub = redis.pubsub()
|
||||
await pubsub.subscribe("processing")
|
||||
|
||||
@@ -211,7 +243,7 @@ class Command(BaseCommand):
|
||||
loop = asyncio.new_event_loop()
|
||||
asyncio.set_event_loop(loop)
|
||||
bot._event_loop = loop
|
||||
loop.create_task(pubsub())
|
||||
loop.create_task(stream())
|
||||
bot.start()
|
||||
try:
|
||||
loop.run_forever()
|
||||
|
||||
Reference in New Issue
Block a user